原文作者:Erica Sadun
原文链接:http://ericasadun.com
时间:2016年7月19日
译者:与狼同行
最近几天我从Swift-Ev看到一个十分有趣的请求。
某位来自Swift-Ev社区成员:当我敲代码的时候,我很多次都会遇到这样一个情型,当使用‘repeat...while’循环时,循环条件依赖于那些在循环体中被声明变量。
repeat {
let success = doSomething()
} while !success
这个请求吸引我的地方是它既需要范围内可见的状态(success)而且还需要这个控制语句的状态(success)没有在外部范围内被声明。
不用担心,其实这个机制已经在Swift中存在,来看看Swift里新的sequence函数。Swift提供了2个种类,两个方式都提供基于循环域来建立状态。
1.public func sequence<T>(first: T, next: (T) -> T?) -> UnfoldSequence<T, (T?, Bool)>
译者解读:
该函数功能为返回从以first”作为开始元素到不断被"next"先前元素所返回的结果的一个队列。
例如:
// 我们可以来走一遍树的元素,从一个节点到它的根元素
for node in sequence(first: leaf, next: { $0.parent }) {
node是叶子节点, 然后是它的父节点, 再然后是它的父节点的父节点, etc.
}
public func sequence<T>(first: T, next: (T) -> T?) -> UnfoldFirstSequence<T> {
// 源码中其实调用了第二种函数,可以看出队列第一个first的元组是true,则直接输出第一个first元素,然后接下来队列中的元素都执行next后返回结果,直到最后结果为nil
return sequence(state: (first, true), next: { (state: inout (T?, Bool)) -> T? in
switch state {
case (let value, true):
state.1 = false
return value
case (let value?, _):
let nextValue = next(value)
state.0 = nextValue
return nextValue
case (nil, _):
return nil
}
})
}
2.public func sequence<T, State>(state: State, next: (inout State) -> T?) -> UnfoldSequence<T, State>
译者解读:
源码为:
public func sequence<T, State>(state: State, next: (inout State) -> T?)
-> UnfoldSequence<T, State> {
return UnfoldSequence(_state: state, _next: next)
//这里调用了另外一个结构体UnfoldSequence,名为展开队列
}
public struct UnfoldSequence<Element, State> : Sequence, IteratorProtocol {
public mutating func next() -> Element? {
guard !_done else { return nil }
if let elt = _next(&_state) {
//这句可以看出为什么sequence函数的next的返回类型都是可选类型,
//当执行next循环语句返回nil,队列剩余部分则不执行next函数,全部返回nil
return elt
} else {
_done = true
return nil
}
}
internal init(_state: State, _next: (inout State) -> Element?) {
self._state = _state
self._next = _next
}
internal var _state: State
internal let _next: (inout State) -> Element?
internal var _done = false
}
两者之间的不同之处在于,第一个更简单的函数产生一个和它状态相同类型的sequence序列。而第二个函数则将状态类型和输出类型区分了出来,因此你可以生成整数,并且同时对字符串做出处理。
现在你来仔细想一想,是不是发现repeat-while真是就像是一个另外一种形式的sequence序列。下面我们来举一个简单的例子。
var i = 0
repeat {
print(i) // some loop body
i = i + 5
} while i <= 100
现在你看了上述的内容,你可以进行重写,来试着把i状态变量纳入控制结构,就像这样:
for i in sequence(first: 0, next: { $0 + 5 }) {
print (i) // some loop body
if i >= 100 { break }
}
或者你可以更大胆一些,试着把所有的行为和状态写入next闭包中,就像这样:
for _ in sequence(first: 0, next: {
print($0) // some loop body
let value = $0 + 5
return value <= 100 ? value : nil
}) {}
这里有3件比较重要的事关于这项第三种写法:
1.这个for循环不需要变量。它只是被用于去执行这个序列。
2.这个循环体是空的,它仅仅被用于完成这个语法。当然你也可以去执行数组(也算一个序列),但那样将会需要申请内存,那个做法是十分浪费的。
3.这个序列当返回nil时会终止。这就意味着这个闭包的返回类型是T？,而T则是第一个参数的类型。在这个例子中return的值只可以返回数字类型,因为这个值并没有有意义的用途,它只是被用于检查false/nil。
如果你想结合Bool条件,有一种快速的方法,可以把Bool类型转化为一个可选。虽然这样做有些过了,但它的确能完成任务。
extension Bool { var opt: Bool? { return self ? self : nil } }
或者,你也可以写一个函数来处理Boolean作为控制语句,这样你就不需要转换Boolean作为可选。
这个perform函数是用于创造一个状态化的repeat-while循环,它使用一个Boolean作为控制,封装了sequence函数的使用,并且允许这个循环体是一个尾随闭包。
func perform<T>(
with state: T,
while test: (T) -> Bool,
repeat body: (inout T) -> Void) -> T {
var updatedState: T = state
let boolSequence = sequence(state: state, next: {
(state: inout T) -> Bool? in
body(&state)
updatedState = state
return test(updatedState) ? true : nil
})
for _ in boolSequence {}
return updatedState
}
// 下面的示例将这些单词连接到一个空格分隔的字符串中。
let joinedWords = perform(
with: ["Lorem", "ipsum", "dolor", "sit", "amet", "consectetur", "adipiscing", "elit"],
while: { $0.count > 1 })
{
(state: inout [String]) in
guard state.count >= 2 else { return }
let (last, butLast) = (state.removeLast(), state.removeLast())
let joinedLast = butLast + " " + last
state.append(joinedLast)
}.first!
debugPrint(joinedWords)
输出结果为:"Lorem ipsum dolor sit amet consectetur adipiscing elit"
这里最关键的地方是初始的单词数组(指["Lorem", "ipsum"...])并没有被存储在循环外部的任何地方,但是可以在循环体内操作。
我相信这个特性正符合社区成员所说的"当使用‘repeat...while’循环时,循环条件依赖于那些在循环体中被声明变量"这句话。
