blocks|key|153936|text|文档中对auto_closure的描述：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|153937|153938|您可以将auto_closure属性应用于参数类型为()并返回表达式类型的函数类型(请参见类型属性)。自动闭包函数捕获指定表达式上的隐式闭包，而不是表达式本身。下面的示例在定义一个非常简单的assert函数时使用auto_closure属性：|blockquote|153939|153940|153941|下面是苹果使用的例子。|153942|func+simpleAssert(condition:+@auto_closure+()+->+Bool,+message:+String)+{
++++if+!condition()+{
++++++++println(message)
++++}
}
let+testNumber+=+5
simpleAssert(testNumber+%25+2+==+0,+"testNumber+isn't+an+even+number.")|code-block|syntax|javascript|153943|基本上，它的意思是你传递一个布尔表达式作为第一个参数，而不是闭包，它会自动为你创建一个闭包。这就是为什么您可以将false传递给该方法，因为它是一个布尔表达式，但不能传递闭包。|153944|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|T|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|U|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|V|8|@]|9|@]|A|$]]|$1|G|3|-4|5|6|7|W|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|X|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|Y|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|Z|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|R|$]]

Description of auto_closure from the docs:

<blockquote>
 You can apply the auto_closure attribute to a function type that has a
 parameter type of () and that returns the type of an expression (see
 Type Attributes). An autoclosure function captures an implicit closure
 over the specified expression, instead of the expression itself. The
 following example uses the auto_closure attribute in defining a very
 simple assert function:
</blockquote>

And here's the example apple uses along with it.

<pre><code>func simpleAssert(condition: @auto_closure () -&gt; Bool, message: String) {
 if !condition() {
 println(message)
 }
}
let testNumber = 5
simpleAssert(testNumber % 2 == 0, "testNumber isn't an even number.")
</code></pre>

Basically what it means is you pass a boolean expression as that first argument instead of a closure and it automatically creates a closure out of it for you. That's why you can pass false into the method because it is a boolean expression, but can't pass a closure.

blocks|key|153958|text|考虑一个带有一个参数的函数，一个不带参数的简单闭包：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|153959|func+f(pred:+()+->+Bool)+{
++++if+pred()+{
++++++++print("It's+true")
++++}
}|code-block|syntax|javascript|153960|要调用此函数，我们必须传入一个闭包|153961|f(pred:+{2+>+1})
//+"It's+true"|153962|如果我们省略了大括号，我们将传入一个表达式，这是一个错误：|153963|f(pred:+2+>+1)
//+error:+'>'+produces+'Bool',+not+the+expected+contextual+result+type+'()+->+Bool'|153964|@autoclosure在表达式周围创建一个自动闭合。因此，当调用者编写像2+>+1这样的表达式时，在传递给f之前，它会自动包装到闭包中成为{2+>+1}。因此，如果我们将此应用于函数f|offset|length|style|CODE|153965|func+f(pred:+@autoclosure+()+->+Bool)+{
++++if+pred()+{
++++++++print("It's+true")
++++}
}

f(pred:+2+>+1)
//+It's+true|153966|因此，它只使用一个表达式，而不需要将其包装在闭包中。|153967|entityMap^0|0|0|0|0|0|0|0|C|11|5|1I|1|1Y|7|2K|1|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|16|8|@$Q|17|R|18|S|T]|$Q|19|R|1A|S|T]|$Q|1B|R|1C|S|T]|$Q|1D|R|1E|S|T]|$Q|1F|R|1G|S|T]]|9|@]|A|$]]|$1|U|3|V|5|D|7|1H|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|1I|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1J|8|@]|9|@]|A|$]]]|Z|$]]

Consider a function that takes one argument, a simple closure that takes no argument:

<pre><code>func f(pred: () -&gt; Bool) {
 if pred() {
 print("It's true")
 }
}
</code></pre>

To call this function, we have to pass in a closure

<pre><code>f(pred: {2 &gt; 1})
// "It's true"
</code></pre>

If we omit the braces, we are passing in an expression and that's an error:

<pre><code>f(pred: 2 &gt; 1)
// error: '&gt;' produces 'Bool', not the expected contextual result type '() -&gt; Bool'
</code></pre>

<code>@autoclosure</code> creates an automatic closure around the expression. So when the caller writes an expression like <code>2 &gt; 1</code>, it's automatically wrapped into a closure to become <code>{2 &gt; 1}</code> before it is passed to <code>f</code>. So if we apply this to the function <code>f</code>:

<pre><code>func f(pred: @autoclosure () -&gt; Bool) {
 if pred() {
 print("It's true")
 }
}

f(pred: 2 &gt; 1)
// It's true
</code></pre>

So it works with just an expression without the need to wrap it in a closure.

blocks|key|2952971|text|这显示了一个有用的@autoclosure+https://airspeedvelocity.net/2014/06/28/extending-the-swift-language-is-cool-but-be-careful/案例|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2952972|2952973|现在，作为第一个参数传递给until的条件表达式将自动包装到闭包表达式中，并且可以在每次循环中调用|blockquote|2952974|2952975|2952976|func+until<L:+LogicValue>(pred:+@auto_closure+()->L,+block:+()->())+{
++++while+!pred()+{
++++++++block()
++++}
}

//+doSomething+until+condition+becomes+true
until(condition)+{
++++doSomething()
}|code-block|syntax|javascript|2952977|entityMap|0|LINK|mutability|MUTABLE|url|https://airspeedvelocity.net/2014/06/28/extending-the-swift-language-is-cool-but-be-careful/^0|9|C|M|2K|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@$9|11|A|12|1|13]]|E|$]]|$1|F|3|-4|5|6|7|14|8|@]|D|@]|E|$]]|$1|G|3|H|5|I|7|15|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|16|8|@]|D|@]|E|$]]|$1|K|3|-4|5|6|7|17|8|@]|D|@]|E|$]]|$1|L|3|M|5|N|7|18|8|@]|D|@]|E|$O|P]]|$1|Q|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]]]

This shows a useful case of <code>@autoclosure</code> <a href="https://airspeedvelocity.net/2014/06/28/extending-the-swift-language-is-cool-but-be-careful/" rel="nofollow">https://airspeedvelocity.net/2014/06/28/extending-the-swift-language-is-cool-but-be-careful/</a>

<blockquote>
 Now, the conditional expression passed as the first parameter to until will be automatically wrapped up into a closure expression and can be called each time around the loop
</blockquote>

<pre><code>func until&lt;L: LogicValue&gt;(pred: @auto_closure ()-&gt;L, block: ()-&gt;()) {
 while !pred() {
 block()
 }
}

// doSomething until condition becomes true
until(condition) {
 doSomething()
}
</code></pre>

blocks|key|2952985|text|这里有一个实际的例子-我的print覆盖(这是Swift+3)：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2952986|func+print(_+item:+@autoclosure+()+->+Any,+separator:+String+=+"+",+terminator:+String+=+"\n")+{
++++#if+DEBUG
++++Swift.print(item(),+separator:separator,+terminator:+terminator)
++++#endif
}|code-block|syntax|javascript|2952987|当你说print(myExpensiveFunction())时，我的print覆盖覆盖了Swift的print，并被调用。因此，myExpensiveFunction()被包装在一个闭包中，并且不进行求值。如果我们处于发布模式，它将永远不会被计算，因为item()将不会被调用。因此，我们有一个版本的print，它在发布模式下不计算其参数。|2952988|entityMap^0|D|5|0|0|3|S|Z|5|1F|5|1T|L|3J|6|47|5|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|N|$]]

Here's a practical example — my <code>print</code> override (this is Swift 3):

<pre><code>func print(_ item: @autoclosure () -&gt; Any, separator: String = " ", terminator: String = "\n") {
 #if DEBUG
 Swift.print(item(), separator:separator, terminator: terminator)
 #endif
}
</code></pre>

When you say <code>print(myExpensiveFunction())</code>, my <code>print</code> override overshadows Swift's <code>print</code> and is called. <code>myExpensiveFunction()</code> is thus wrapped in a closure and not evaluated. If we're in Release mode, it will never be evaluated, because <code>item()</code> won't be called. Thus we have a version of <code>print</code> that doesn't evaluate its arguments in Release mode.

blocks|key|2952990|text|这只是一种在闭包调用中去掉大括号的方法，简单的例子：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2952991|++++let+nonAutoClosure+=+{+(arg1:+()+->+Bool)+->+Void+in+}
++++let+non+=+nonAutoClosure(+{+2+>+1}+)

++++let+autoClosure+=+{+(arg1:+@autoclosure+()+->+Bool)+->+Void+in+}
++++var+auto+=+autoClosure(+2+>+1+)+//+notice+curly+braces+omitted|code-block|syntax|javascript|2952992|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

It's just a way to get rid of the curly braces in a closure call, simple example:

<pre><code> let nonAutoClosure = { (arg1: () -&gt; Bool) -&gt; Void in }
 let non = nonAutoClosure( { 2 &gt; 1} )

 let autoClosure = { (arg1: @autoclosure () -&gt; Bool) -&gt; Void in }
 var auto = autoClosure( 2 &gt; 1 ) // notice curly braces omitted
</code></pre>

blocks|key|2740180|text|邮箱：@autoclosure|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|2740181|@autoclosure是接受熟化函数(或返回类型)的函数参数，而通用closure则接受原始函数|CODE|2740182|2740183|@autoclosure实参类型参数必须为'()‘@autoclosure()|unordered-list-item|2740184|2740185|2740186|@autoclosure接受仅具有适当返回类型的任何函数|2740187|闭包的结果由demand|2740188|计算|2740189|让我们来看一个例子|2740190|func+testClosures()+{

++++//closures
++++XCTAssertEqual("fooWithClosure0+foo0",+fooWithClosure0(p:+foo0))
++++XCTAssertEqual("fooWithClosure1+foo1+1",+fooWithClosure1(p:+foo1))
++++XCTAssertEqual("fooWithClosure2+foo2+3",+fooWithClosure2(p:+foo2))
++++
++++XCTAssertEqual("fooWithClosure2+foo2+3",+fooWithClosure2(p:+{+(i1,+i2)+->+String+in
++++++++return+"fooWithClosure2+"+%2B+"foo2+"+%2B+String(i1+%2B+i2)
++++}))
++++
++++//@autoclosure
++++XCTAssertEqual("fooWithAutoClosure+HelloWorld",+fooWithAutoClosure(a:+"HelloWorld"))
++++
++++XCTAssertEqual("fooWithAutoClosure+foo0",+fooWithAutoClosure(a:+foo0()))
++++XCTAssertEqual("fooWithAutoClosure+foo1+1",+fooWithAutoClosure(a:+foo1(i1:+1)))
++++XCTAssertEqual("fooWithAutoClosure+foo2+3",+fooWithAutoClosure(a:+foo2(i1:+1,+i2:+2)))

}

//functions+block
func+foo0()+->+String+{
++++return+"foo0"
}

func+foo1(i1:+Int)+->+String+{
++++return+"foo1+"+%2B+String(i1)
}

func+foo2(i1:+Int,+i2:+Int)+->+String+{
++++return+"foo2+"+%2B+String(i1+%2B+i2)
}

//closures+block
func+fooWithClosure0(p:+()+->+String)+->+String+{
++++return+"fooWithClosure0+"+%2B+p()
}

func+fooWithClosure1(p:+(Int)+->+String)+->+String+{
++++return+"fooWithClosure1+"+%2B+p(1)
}

func+fooWithClosure2(p:+(Int,+Int)+->+String)+->+String+{
++++return+"fooWithClosure2+"+%2B+p(1,+2)
}

//@autoclosure
func+fooWithAutoClosure(a:+@autoclosure+()+->+String)+->+String+{
++++return+"fooWithAutoClosure+"+%2B+a()
}|code-block|syntax|javascript|2740191|entityMap^0|3|C|0|0|C|Z|7|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|13|8|@$9|14|A|15|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|16|8|@$9|17|A|18|B|H]|$9|19|A|1A|B|H]]|D|@]|E|$]]|$1|I|3|-4|5|6|7|1B|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|1C|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|1D|8|@]|D|@]|E|$]]|$1|N|3|-4|5|6|7|1E|8|@]|D|@]|E|$]]|$1|O|3|P|5|L|7|1F|8|@]|D|@]|E|$]]|$1|Q|3|R|5|L|7|1G|8|@]|D|@]|E|$]]|$1|S|3|T|5|6|7|1H|8|@]|D|@]|E|$]]|$1|U|3|V|5|6|7|1I|8|@]|D|@]|E|$]]|$1|W|3|X|5|Y|7|1J|8|@]|D|@]|E|$Z|10]]|$1|11|3|-4|5|6|7|1K|8|@]|D|@]|E|$]]]|12|$]]

@autoclosure
<code>@autoclosure</code> is a function parameter which accept a cooked function(or returned type) meanwhile a general <code>closure</code> accept a raw function
<ul>
<li>@autoclosure argument type parameter must be '()'
<pre><code>@autoclosure()
</code></pre>
</li>
<li>@autoclosure accept any function with only appropriate returned type</li>
<li>Result of closure is calculated by demand</li>
</ul>
Let's take a look at example
<pre><code>func testClosures() {

 //closures
 XCTAssertEqual(&quot;fooWithClosure0 foo0&quot;, fooWithClosure0(p: foo0))
 XCTAssertEqual(&quot;fooWithClosure1 foo1 1&quot;, fooWithClosure1(p: foo1))
 XCTAssertEqual(&quot;fooWithClosure2 foo2 3&quot;, fooWithClosure2(p: foo2))
 
 XCTAssertEqual(&quot;fooWithClosure2 foo2 3&quot;, fooWithClosure2(p: { (i1, i2) -&gt; String in
 return &quot;fooWithClosure2 &quot; + &quot;foo2 &quot; + String(i1 + i2)
 }))
 
 //@autoclosure
 XCTAssertEqual(&quot;fooWithAutoClosure HelloWorld&quot;, fooWithAutoClosure(a: &quot;HelloWorld&quot;))
 
 XCTAssertEqual(&quot;fooWithAutoClosure foo0&quot;, fooWithAutoClosure(a: foo0()))
 XCTAssertEqual(&quot;fooWithAutoClosure foo1 1&quot;, fooWithAutoClosure(a: foo1(i1: 1)))
 XCTAssertEqual(&quot;fooWithAutoClosure foo2 3&quot;, fooWithAutoClosure(a: foo2(i1: 1, i2: 2)))

}

//functions block
func foo0() -&gt; String {
 return &quot;foo0&quot;
}

func foo1(i1: Int) -&gt; String {
 return &quot;foo1 &quot; + String(i1)
}

func foo2(i1: Int, i2: Int) -&gt; String {
 return &quot;foo2 &quot; + String(i1 + i2)
}

//closures block
func fooWithClosure0(p: () -&gt; String) -&gt; String {
 return &quot;fooWithClosure0 &quot; + p()
}

func fooWithClosure1(p: (Int) -&gt; String) -&gt; String {
 return &quot;fooWithClosure1 &quot; + p(1)
}

func fooWithClosure2(p: (Int, Int) -&gt; String) -&gt; String {
 return &quot;fooWithClosure2 &quot; + p(1, 2)
}

//@autoclosure
func fooWithAutoClosure(a: @autoclosure () -&gt; String) -&gt; String {
 return &quot;fooWithAutoClosure &quot; + a()
}
</code></pre>

I noticed when writing an <code>assert</code> in Swift that the first value is typed as

<pre><code>@autoclosure() -&gt; Bool
</code></pre>

with an overloaded method to return a generic <code>T</code> value, to test existence via the <code>LogicValue</code> <code>protocol</code>. 

However sticking strictly to the question at hand. It appears to want an <code>@autoclosure</code> that returns a <code>Bool</code>.

Writing an actual closure that takes no parameters and returns a Bool does not work, it wants me to call the closure to make it compile, like so:

<pre><code>assert({() -&gt; Bool in return false}(), "No user has been set", file: __FILE__, line: __LINE__)
</code></pre>

However simply passing a Bool works:

<pre><code>assert(false, "No user has been set", file: __FILE__, line: __LINE__)
</code></pre>

So what is going on? What is <code>@autoclosure</code>?

Edit: <code>@auto_closure</code> was renamed <code>@autoclosure</code>

How to use Swift @autoclosure

我注意到在Swift中编写assert时，第一个值的类型为@autoclosure() -> Bool使用重载方法返回泛型T值，通过LogicValue protocol测试是否存在。然而，严格地坚持手头的问题。它似乎需要一个返回Bool的@autoclosure。编写一个不带参数并返回布尔值的实际闭包是不起作用的，它...

问如何使用Swift @autoclosure
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何使用Swift @autoclosureEN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何使用Swift @autoclosure
EN