Closures¶ クロージャ¶

Closure Expressions¶ さまざまなクロージャ式¶

Nested functions, as introduced in Nested Functions, are a convenient means of naming and defining self-contained blocks of code as part of a larger function. However, it’s sometimes useful to write shorter versions of function-like constructs without a full declaration and name. This is particularly true when you work with functions or methods that take functions as one or more of their arguments. 入れ子にされた関数は、入れ子にされた関数の中で紹介されるように、より大きい関数の一部として、いろいろな完全独立のコードの塊を名前をつけて定義する便利な手段です。しかし、まるまる完全な宣言や名前なしに、関数のような構造物のより短いものをいろいろと書くことは、時々役に立ちます。１つ以上のそれの引数として関数をとる関数またはメソッドをあなたが扱うとき、これは特に当てはまります。

Closure expressions are a way to write inline closures in a brief, focused syntax. Closure expressions provide several syntax optimizations for writing closures in a shortened form without loss of clarity or intent. The closure expression examples below illustrate these optimizations by refining a single example of the sorted(by:) method over several iterations, each of which expresses the same functionality in a more succinct way. クロージャ式は、簡潔な、焦点のあった構文で、処理の流れに組み込まれた（行内の、インラインの）クロージャを書く方法です。クロージャ式は、いくつかの構文最適化を、ある省略形式で明快さや意図の損失なしでクロージャを書くために提供します。以下のクロージャ式の例は、これらの最適化を１つの例のsorted(by:)メソッドの改良をいくどか繰り返していくことで解説します、そして、そのそれぞれは同じ機能性をより簡潔な方法で表わします。

Trailing Closures¶ 後付クロージャ¶

If you need to pass a closure expression to a function as the function’s final argument and the closure expression is long, it can be useful to write it as a trailing closure instead. You write a trailing closure after the function call’s parentheses, even though the trailing closure is still an argument to the function. When you use the trailing closure syntax, you don’t write the argument label for the first closure as part of the function call. A function call can include multiple trailing closures; however, the first few examples below use a single trailing closure. あなたが関数の最後の引数としてクロージャ式を関数に渡す必要がある、そしてそのクロージャ式が長いならば、代わりに後付クロージャとしてそれを書くことは役に立つことがありえます。あなたは、後付クロージャを関数呼び出しのもつ丸括弧それらの後に書きます、そうであってもその後付クロージャは依然として関数への引数のままです。あなたが後付クロージャ構文を使うとき、あなたは、その最初のクロージャに対して関数呼び出しの一部として引数ラベルを書きません。関数呼び出しは、複数の後付クロージャを含むことができます；しかしながら、下の最初の幾つかの例はただ１つだけ後付クロージャを使います。

The string-sorting closure from the Closure Expression Syntax section above can be written outside of the sorted(by:) method’s parentheses as a trailing closure: 上のクロージャ式構文の節の文字列を分類するクロージャは、後付クロージャとしてsorted(by:)関数の括弧の外側に書かれることができます：

If a closure expression is provided as the function’s or method’s only argument and you provide that expression as a trailing closure, you don’t need to write a pair of parentheses () after the function or method’s name when you call the function: あるクロージャ式が関数のもつまたはメソッドのもつ唯一の引数として提供され、そしてあなたが後付クロージャとしてその式を提供するならば、あなたがその関数を呼ぶ時に、一対の丸括弧()を関数やメソッドの名前の後に書く必要はありません：

Trailing closures are most useful when the closure is sufficiently long that it isn’t possible to write it inline on a single line. As an example, Swift’s Array type has a map(_:) method, which takes a closure expression as its single argument. The closure is called once for each item in the array, and returns an alternative mapped value (possibly of some other type) for that item. You specify the nature of the mapping and the type of the returned value by writing code in the closure that you pass to map(_:). クロージャがそれをただ１つの行の行内に書くことが可能でないほど長いとき、後付クロージャは最も役に立ちます。例として、スウィフトのArray型はmap(_:)メソッドを持ちます、それは、そのただ１つの引数としてクロージャ式をとります。クロージャは、配列の中の各項目に対して一度だけ呼ばれて、その項目のための代わりの対応付けされた（おそらく何か他の型の）値を返します。あなたは、マッピング（対応付け）の性質と返される値の型を、あなたがmap(_:)に渡すクロージャの中でコードを記述することによって指定します。

After applying the provided closure to each array element, the map(_:) method returns a new array containing all of the new mapped values, in the same order as their corresponding values in the original array. 提供されたクロージャを各配列要素に適用した後に、map(_:)メソッドは、新しい対応付けられる値の全てを、もとの配列のそれらの対応する値と同じ順序で含んでいる新しい配列を返します。

Here’s how you can use the map(_:) method with a trailing closure to convert an array of Int values into an array of String values. The array [16, 58, 510] is used to create the new array ["OneSix", "FiveEight", "FiveOneZero"]: ここに、あなたがInt値の配列をString値の配列に変えるために後付クロージャとともにmap(_:)メソッドをどのように使用できるかがあります。配列[16, 58, 510]は、新しい配列["OneSix", "FiveEight", "FiveOneZero"]をつくるために使われます：

The code above creates a dictionary of mappings between the integer digits and English-language versions of their names. It also defines an array of integers, ready to be converted into strings. 上のコードは、整数桁とそれらの名前の英語版の間で対応付けをする辞書を作成します。それはまた、文字列に変換される準備ができている整数の配列も定義します。

You can now use the numbers array to create an array of String values, by passing a closure expression to the array’s map(_:) method as a trailing closure: あなたは、現在、このnumbers配列をString値の配列をつくるために使うことが、あるクロージャ式を配列のmap(_:)メソッドに後付クロージャとして渡すことによって、可能です：

The map(_:) method calls the closure expression once for each item in the array. You don’t need to specify the type of the closure’s input parameter, number, because the type can be inferred from the values in the array to be mapped. map(_:)メソッドは、配列の中の各項目に対して一度だけクロージャ式を呼びます。あなたはクロージャの入力パラメータ、numberの型を指定する必要がありません、なぜならその型は対応付けされる配列の値から推論されることが可能だからです。

In this example, the variable number is initialized with the value of the closure’s number parameter, so that the value can be modified within the closure body. (The parameters to functions and closures are always constants.) The closure expression also specifies a return type of String, to indicate the type that will be stored in the mapped output array. この例では、変数numberはこのクロージャの持つnumberパラメータの値を使って初期化されます、それでその値はクロージャ本体の内部で修正されることができます。（関数およびクロージャに対するパラメータは常に定数です。）クロージャ式はまた、Stringの戻り型を指定します、それによってマップされた出力配列の中に格納されることになる型を指し示します。

The closure expression builds a string called output each time it’s called. It calculates the last digit of number by using the remainder operator (number % 10), and uses this digit to look up an appropriate string in the digitNames dictionary. The closure can be used to create a string representation of any integer greater than zero. クロージャ式は、それが呼ばれるたびに、outputと呼ばれる文字列をつくります。それは、numberの最後の桁を剰余演算子を使用することによって計算して（number % 10）、この桁をdigitNames辞書で適切な文字列を捜すために使います。このクロージャは、ゼロより大きいあらゆる整数の文字列表現を作るために使われることが出来ます。

The string retrieved from the digitNames dictionary is added to the front of output, effectively building a string version of the number in reverse. (The expression number % 10 gives a value of 6 for 16, 8 for 58, and 0 for 510.) digitNames辞書から取り出される文字列はoutputの前方に加えられて、うまい具合に数の文字列版を逆の順序で造ります。（式数number % 10は、16のために6、58のために8、510のために0の値を与えます）。

The number variable is then divided by 10. Because it’s an integer, it’s rounded down during the division, so 16 becomes 1, 58 becomes 5, and 510 becomes 51. number変数は、それから10で割られます。それが整数であるので、除算のときに端数を切り捨てられます、それで16が1に、58が5に、そして510は51になります。

The process is repeated until number is equal to 0, at which point the output string is returned by the closure, and is added to the output array by the map(_:) method. この処理はnumberが0に等しくなるまで繰り返されます、その時点でoutput文字列がクロージャによって返されて、そしてmap(_:)メソッドによって出力配列に加えられます。

The use of trailing closure syntax in the example above neatly encapsulates the closure’s functionality immediately after the function that closure supports, without needing to wrap the entire closure within the map(_:) method’s outer parentheses. 上の例での後付クロージャ構文の使用は、クロージャの機能性をクロージャが手助けする関数の直後に手際よく要約していて、クロージャ全体をmap(_:)メソッドの持つ外側の丸括弧の内部に包む必要はありません。

If a function takes multiple closures, you omit the argument label for the first trailing closure and you label the remaining trailing closures. For example, the function below loads a picture for a photo gallery: 関数が複数のクロージャを取るならば、あなたは最初の後付クロージャに対して引数ラベルを省きます、そしてあなたは残りの後付クロージャにラベルをつけます。例えば、下の関数はあるピクチャをフォトギャラリーに対してロードします：

When you call this function to load a picture, you provide two closures. The first closure is a completion handler that displays a picture after a successful download. The second closure is an error handler that displays an error to the user. あなたがこの関数を呼び出してあるピクチャをロードする時、あなたは２つのクロージャを提供します。最初のクロージャはある完了ハンドラです、それはあるピクチャを成功したダウンロードの後に表示します。２番目のクロージャは、エラーハンドラです、それはエラーをユーザに対して表示します。

In this example, the loadPicture(from:completion:onFailure:) function dispatches its network task into the background, and calls one of the two completion handlers when the network task finishes. Writing the function this way lets you cleanly separate the code that’s responsible for handling a network failure from the code that updates the user interface after a successful download, instead of using just one closure that handles both circumstances. この例において、loadPicture(from:completion:onFailure:)関数は、それのネットワークタスクをバックグラウンドへとディスパッチします、そして２つの完了ハンドラのうちの１つをネットワークタスクが終了する時に呼び出します。関数をこの方法で書くことは、あなたにネットワーク失敗を取り扱うことに責任を持つコードを、成功したダウンロードの後にユーザインターフェイスを更新するコードから分離させます。

Capturing Values¶ 値を捕獲する¶

A closure can capture constants and variables from the surrounding context in which it’s defined. The closure can then refer to and modify the values of those constants and variables from within its body, even if the original scope that defined the constants and variables no longer exists. クロージャは、それが定義される周囲の前後関係から、定数と変数を捕獲（キャプチャ）できます。クロージャはそれから、その本文内からそれらの定数と変数の値に言及することや修正することができます、たとえその定数と変数を定義した本来のスコープがもはや存在しないとしてもです。

In Swift, the simplest form of a closure that can capture values is a nested function, written within the body of another function. A nested function can capture any of its outer function’s arguments and can also capture any constants and variables defined within the outer function. スウィフトにおいて、値をキャプチャできるクロージャの最も単純な形式は、別の関数の本文内に書かれる、入れ子にされた関数です。入れ子にされた関数は、その外側の関数の持つ引数の何でも捕獲することができ、また外側の関数の範囲内で定義されるどんな定数や変数でも捕獲することができます。

Here’s an example of a function called makeIncrementer, which contains a nested function called incrementer. The nested incrementer() function captures two values, runningTotal and amount, from its surrounding context. After capturing these values, incrementer is returned by makeIncrementer as a closure that increments runningTotal by amount each time it’s called. ここに、makeIncrementerと呼ばれる関数の例があります、それはincrementerと呼ばれる入れ子にされた関数を含みます。入れ子にされたincrementer()関数は、それを取り囲む前後関係から２つの値、runningTotalとamountを捕獲します。これらの値を捕獲した後に、incrementerはmakeIncrementerによって、それが呼ばれるたびにrunningTotalをamountによって増加させるクロージャとして返されます。

The return type of makeIncrementer is () -> Int. This means that it returns a function, rather than a simple value. The function it returns has no parameters, and returns an Int value each time it’s called. To learn how functions can return other functions, see Function Types as Return Types. makeIncrementerの戻り型は、() -> Intです。これは、それが関数を返すことを意味します、単純なひとつの値ではなく。それが返す関数は、パラメータを持たず、それが呼ばれるたびにInt値を返します。関数が他の関数を返すことができる方法を学ぶために、戻り型としての関数型を見てください。

The makeIncrementer(forIncrement:) function defines an integer variable called runningTotal, to store the current running total of the incrementer that will be returned. This variable is initialized with a value of 0. makeIncrementer(forIncrement:)関数は、返されるincrementerの現時点での合計を格納するために、runningTotalと呼ばれる整数変数を定義します。この変数は、値0で初期化されます。

The makeIncrementer(forIncrement:) function has a single Int parameter with an argument label of forIncrement, and a parameter name of amount. The argument value passed to this parameter specifies how much runningTotal should be incremented by each time the returned incrementer function is called. The makeIncrementer function defines a nested function called incrementer, which performs the actual incrementing. This function simply adds amount to runningTotal, and returns the result. makeIncrementer(forIncrement:)関数は、forIncrementの引数ラベル、そしてamountのパラメータ名を持つ、ただ１つのIntパラメータを持ちます。このパラメータに渡された引き数の値は、返されたインクリメンタ関数（漸増器関数）が呼ばれるたびに、どのくらいrunningTotalが増やされなければならないかについて指定します。makeIncrementer関数はincrementerと呼ばれる入れ子にされた関数を定義します、それは、実際に増やすことを実行します。この関数は、単にamountをrunningTotalに加えて、結果を返します。

When considered in isolation, the nested incrementer() function might seem unusual: 切り離して考えたとき、入れ子にされたincrementer()関数は普通でないものに見えるかもしれません：

The incrementer() function doesn’t have any parameters, and yet it refers to runningTotal and amount from within its function body. It does this by capturing a reference to runningTotal and amount from the surrounding function and using them within its own function body. Capturing by reference ensures that runningTotal and amount don’t disappear when the call to makeIncrementer ends, and also ensures that runningTotal is available the next time the incrementer function is called. incrementer()関数には全くパラメータがありません、それなのに、それはその関数本文内からrunningTotalとamountに言及します。それは、それを囲んでいる関数からrunningTotalとamountへの参照を捕獲して、それらをそれ自身の関数本文内で使うことによってこれを行います。参照を捕獲することは、runningTotalとamountが、makeIncrementerへの呼び出しが終わる時に消えてなくならないことを確かなものにします、そしてまたrunningTotalが、incrementer関数が呼ばれる次の時に利用可能であることを確実にします。

Here’s an example of makeIncrementer in action: 動作しているmakeIncrementerの例がここにあります：

This example sets a constant called incrementByTen to refer to an incrementer function that adds 10 to its runningTotal variable each time it’s called. Calling the function multiple times shows this behavior in action: この例は、incrementByTenと呼ばれる定数を、それが呼ばれるたびに10をそのrunningTotal変数に加えるあるインクリメンタ関数に言及するように設定します。この関数を複数回呼ぶことは、活動中にこの挙動を示します：

If you create a second incrementer, it will have its own stored reference to a new, separate runningTotal variable: あなたが第２のインクリメンタをつくるならば、それは、独自に格納された、ある新しい、別個のrunningTotal変数への参照を持ちます：

Calling the original incrementer (incrementByTen) again continues to increment its own runningTotal variable, and doesn’t affect the variable captured by incrementBySeven: 最初のインクリメンタ（incrementByTen）を再び呼ぶことは、それ独自のrunningTotal変数を増加させることを継続します、そしてincrementBySevenによってキャプチャされる変数に影響しません。

Closures Are Reference Types¶ クロージャは参照型です¶

In the example above, incrementBySeven and incrementByTen are constants, but the closures these constants refer to are still able to increment the runningTotal variables that they have captured. This is because functions and closures are reference types. 上の例で、incrementBySevenとincrementByTenは定数です、しかしこれらの定数が言及するクロージャはそれでもなお、それらが捕獲したrunningTotal変数を増加させることができます。これは、関数とクロージャが参照型であるからです。

Whenever you assign a function or a closure to a constant or a variable, you are actually setting that constant or variable to be a reference to the function or closure. In the example above, it’s the choice of closure that incrementByTen refers to that’s constant, and not the contents of the closure itself. あなたが関数やクロージャを定数または変数に代入するときはいつでも、あなたは実際はその定数または変数が関数やクロージャへの参照であると設定しています。上の例では、それは「クロージャの選択」です、それがincrementByTenが参照するものであり、それは定数であり、そしてクロージャ自身の内容ではありません。

This also means that if you assign a closure to two different constants or variables, both of those constants or variables refer to the same closure. これはまた、あなたがクロージャを２つの異なる定数または変数に代入するならば、それらの定数または変数の両方とも同じクロージャに言及することを意味するでしょう。

The example above shows that calling alsoIncrementByTen is the same as calling incrementByTen. Because both of them refer to the same closure, they both increment and return the same running total. 上の例は、alsoIncrementByTenを呼び出すことはincrementByTenを呼び出す事と同じであるのを示します。それらの両方ともが同じクロージャを参照することから、それらは両方とも漸増しますそして同じ実行総数を返します。

Escaping Closures¶ 脱出クロージャ¶

A closure is said to escape a function when the closure is passed as an argument to the function, but is called after the function returns. When you declare a function that takes a closure as one of its parameters, you can write @escaping before the parameter’s type to indicate that the closure is allowed to escape. クロージャが引数として関数に渡される、しかしその関数が戻った後に呼び出されるとき、クロージャは関数を脱出すると言われます。あなたがある関数、それのパラメータの１つとしてクロージャをとるものを宣言する時、あなたは@escapingをパラメータの型の前に書くことによって、そのクロージャが脱出を許可されるのを指し示すことができます。

One way that a closure can escape is by being stored in a variable that’s defined outside the function. As an example, many functions that start an asynchronous operation take a closure argument as a completion handler. The function returns after it starts the operation, but the closure isn’t called until the operation is completed—the closure needs to escape, to be called later. For example: クロージャが脱出できる１つの方法は、関数の外側で定義される変数に格納されることによってです。例として、非同期の演算を開始する多くの関数は、クロージャ引数を完了ハンドラとして取ります。関数は、それが演算を開始した後に戻ります、しかしクロージャはその演算が完了されるまで呼び出されません—このクロージャは脱出すること、後で呼び出されること、を必要とします。例えば：

The someFunctionWithEscapingClosure(_:) function takes a closure as its argument and adds it to an array that’s declared outside the function. If you didn’t mark the parameter of this function with @escaping, you would get a compile-time error. someFunctionWithEscapingClosure(_:)関数は、クロージャをそれの引数として取ります、そしてそれを関数の外側で宣言される配列に加えます。あなたがこの関数のパラメータを@escapingで印しないならば、あなたはコンパイル時エラーを得るでしょう。

An escaping closure that refers to self needs special consideration if self refers to an instance of a class. Capturing self in an escaping closure makes it easy to accidentally create a strong reference cycle. For information about reference cycles, see Automatic Reference Counting. selfを参照する脱出クロージャは、もしselfがあるクラスのインスタンスを参照するならば、特別な配慮を必要とします。selfを脱出クロージャの中にキャプチャすることは、誤って強い参照循環を作りやすくします。参照循環についての情報として、自動参照カウントを見てください。

Normally, a closure captures variables implicitly by using them in the body of the closure, but in this case you need to be explicit. If you want to capture self, write self explicitly when you use it, or include self in the closure’s capture list. Writing self explicitly lets you express your intent, and reminds you to confirm that there isn’t a reference cycle. For example, in the code below, the closure passed to someFunctionWithEscapingClosure(_:) refers to self explicitly. In contrast, the closure passed to someFunctionWithNonescapingClosure(_:) is a nonescaping closure, which means it can refer to self implicitly. 通常、クロージャは変数それらのキャプチャを、それらをクロージャの本体の中で使うことによって暗黙的に行います、しかしこの場合にはあなたは明示的にする必要があります。あなたがselfをキャプチャしたいならば、selfを明示的にあなたがそれを使う時に書いてください、またはselfをクロージャのもつキャプチャリストの中に含めてください。selfを明示的に書くことは、あなたにあなたの意図を表現させます、そして参照循環がないことを確認するのをあなたに思い出させます。例えば、下のコードにおいて、someFunctionWithEscapingClosure(_:)に渡されるクロージャは、selfを明示的に参照します。対照的に、someFunctionWithNonescapingClosure(_:)に渡されるクロージャは、非脱出クロージャです、そのことは、それがselfを暗黙的に参照できるのを意味します。

Here’s a version of doSomething() that captures self by including it in the closure’s capture list, and then refers to self implicitly: ここにdoSomething()のある変異版があります、それはselfを、それをクロージャのもつキャプチャリストの中に含めることによってキャプチャします、そしてそれからselfを暗黙的に参照します：

If self is an instance of a structure or an enumeration, you can always refer to self implicitly. However, an escaping closure can’t capture a mutable reference to self when self is an instance of a structure or an enumeration. Structures and enumerations don’t allow shared mutability, as discussed in Structures and Enumerations Are Value Types. selfがある構造体または列挙のインスタンスであるならば、あなたは常にselfを暗黙的に参照できます。しかしながら、脱出クロージャはselfに対する可変参照をキャプチャすることが、selfが構造体または列挙のインスタンスである場合はできません。構造体と列挙は、共有された可変性を許可しません、構造体と列挙は値型ですで記述されるように。

The call to the someFunctionWithEscapingClosure function in the example above is an error because it’s inside a mutating method, so self is mutable. That violates the rule that escaping closures can’t capture a mutable reference to self for structures. someFunctionWithEscapingClosure関数への呼び出しは上の例においてエラーです、なぜならそれがある可変メソッドの内部にあるためです、それでselfは可変です。それは、脱出クロージャはselfへの可変参照を構造体についてはキャプチャできないという規則に違反します。

Autoclosures¶ 自動クロージャ¶

An autoclosure is a closure that’s automatically created to wrap an expression that’s being passed as an argument to a function. It doesn’t take any arguments, and when it’s called, it returns the value of the expression that’s wrapped inside of it. This syntactic convenience lets you omit braces around a function’s parameter by writing a normal expression instead of an explicit closure. 自動クロージャは、自動的に作成されて、引数として関数に渡されている式を包み込むクロージャです。それは、全く引数を取りません、そしてそれが呼ばれる時、その内部に包み込まれた式の値を返します。この統語上の便宜は、明示的なクロージャの代わりに通常の関数を書くことによって、あなたに関数のパラメータのまわりの波括弧を省略させます。

It’s common to call functions that take autoclosures, but it’s not common to implement that kind of function. For example, the assert(condition:message:file:line:) function takes an autoclosure for its condition and message parameters; its condition parameter is evaluated only in debug builds and its message parameter is evaluated only if condition is false. 自動クロージャを取る関数を呼び出すのは普通です、しかしそのような関数を実装するのは一般的ではありません。例えば、assert(condition:message:file:line:)関数は自動クロージャをそれのconditionとmessageパラメータとして取ります；それのconditionパラメータはデバッグビルドにおいてのみ評価されます、そしてそれのmessageパラメータはconditionがfalseである場合にのみ評価されます。

An autoclosure lets you delay evaluation, because the code inside isn’t run until you call the closure. Delaying evaluation is useful for code that has side effects or is computationally expensive, because it lets you control when that code is evaluated. The code below shows how a closure delays evaluation. 自動クロージャは、あなたに評価を延期させます、内部のコードはあなたがそのクロージャを呼び出すまで実行されないからです。評価を遅らせることは、副作用を持つまたは計算的に高くつくコードに対して有用です、なぜならそれがあなたに何時そのコードが評価されるかを制御させるからです。下のコードは、どのようにクロージャが評価を遅らすかを示します。

Even though the first element of the customersInLine array is removed by the code inside the closure, the array element isn’t removed until the closure is actually called. If the closure is never called, the expression inside the closure is never evaluated, which means the array element is never removed. Note that the type of customerProvider isn’t String but () -> String—a function with no parameters that returns a string. たとえcustomersInLine配列の最初の要素がクロージャ内部のコードによって取り除かれるとしても、その配列要素はクロージャが実際に呼び出されるまで実行されません。このクロージャが決して呼び出されないならば、クロージャ内部の式は決して評価されません、それは配列要素が決して取り除かれないことを意味します。注意すべきは、customerProviderの型はStringではなく() -> String — ある文字列を返すパラメータのない関数 — であることです。

You get the same behavior of delayed evaluation when you pass a closure as an argument to a function. あなたが同じ挙動の延期した評価を得るのは、あなたがクロージャを引数として関数に渡す時です。

The serve(customer:) function in the listing above takes an explicit closure that returns a customer’s name. The version of serve(customer:) below performs the same operation but, instead of taking an explicit closure, it takes an autoclosure by marking its parameter’s type with the @autoclosure attribute. Now you can call the function as if it took a String argument instead of a closure. The argument is automatically converted to a closure, because the customerProvider parameter’s type is marked with the @autoclosure attribute. 上で記載されるserve(customer:)関数は、次の顧客の名前を返す、ある明示的なクロージャを取ります。下のバージョンのserve(customer:)は同じ演算を実行します、しかし明示的なクロージャを取るのではなく、それは自動クロージャを、それのパラメータの型を@autoclosure属性で記することによって取ります。今やあなたはこの関数を、まるでそれがクロージャではなくString引数を取るかのように呼び出せます。引数は、自動的にクロージャに変換されます、なぜならcustomerProviderパラメータの型は@autoclosure属性で印されるからです。

If you want an autoclosure that’s allowed to escape, use both the @autoclosure and @escaping attributes. The @escaping attribute is described above in Escaping Closures. あなたが脱出を許可される自動クロージャを望むならば、@autoclosureと@escaping属性を両方とも使ってください。@escaping属性は、上の脱出クロージャで解説されます。

In the code above, instead of calling the closure passed to it as its customerProvider argument, the collectCustomerProviders(_:) function appends the closure to the customerProviders array. The array is declared outside the scope of the function, which means the closures in the array can be executed after the function returns. As a result, the value of the customerProvider argument must be allowed to escape the function’s scope. 上のコードにおいて、それのcustomerProvider引数としてそれに渡されるクロージャを呼び出す代わりに、collectCustomerProviders(_:)関数は、そのクロージャをcustomerProviders配列に追加します。この配列は関数のスコープの外側で宣言されます、それは配列の中のクロージャが関数が戻った後で実行されることができるのを意味します。その結果、customerProvider引数の値は関数のスコープを脱出することを許されなければなりません。