On This Page

Functions 関数

Functions are self-contained chunks of code that perform a specific task. You give a function a name that identifies what it does, and this name is used to “call” the function to perform its task when needed. 関数は、特定の作業を実行する完全独立の大きな塊のコードです。あなたは関数にそれが何をするかについて識別する名前を与えます、そしてこの名前が必要なときその作業を実行するために関数を「呼び出す」のに使われます。

Swift’s unified function syntax is flexible enough to express anything from a simple C-style function with no parameter names to a complex Objective-C-style method with names and argument labels for each parameter. Parameters can provide default values to simplify function calls and can be passed as in-out parameters, which modify a passed variable once the function has completed its execution. スウィフトの統合された関数構文は、十分な柔軟性があり、パラメータ名を持たない単純なCスタイルの関数から、各パラメータに対して名前および引数ラベルをもつ複雑なObjective-Cスタイルのメソッドまで、何でも表わします。パラメータは、関数呼び出しを単純化するために初期値を提供することができます、そしてひとたび関数がその実行を完了し終えれば渡された変数を修正するin-outパラメータとして渡されることができます。

Every function in Swift has a type, consisting of the function’s parameter types and return type. You can use this type like any other type in Swift, which makes it easy to pass functions as parameters to other functions, and to return functions from functions. Functions can also be written within other functions to encapsulate useful functionality within a nested function scope. スウィフトのあらゆる関数は、その関数のパラメータ型と戻り型から成る、ある型を持ちます。あなたはスウィフトの他のあらゆる型と同じようにこの型を使うことができます、そしてそれは、他の関数へのパラメータとして関数を渡して、関数から関数を返すことを簡単にします。関数は、また、他の関数の内部で記述されることで、役に立つ機能性を入れ子にされた関数スコープ内でカプセル化することができます。

Defining and Calling Functions 関数の定義と呼び出し

When you define a function, you can optionally define one or more named, typed values that the function takes as input, known as parameters. You can also optionally define a type of value that the function will pass back as output when it’s done, known as its return type. あなたがある関数を定義するとき、あなたは随意にその関数が入力としてとる、１つ以上の名前をつけられ型付けされた値、パラメータとして知られるものを定義できます。あなたはまた、随意にその関数が実行を終えたとき出力として逆に渡す値の型、その戻り型として知られるものを定義できます。

Every function has a function name, which describes the task that the function performs. To use a function, you “call” that function with its name and pass it input values (known as arguments) that match the types of the function’s parameters. A function’s arguments must always be provided in the same order as the function’s parameter list. あらゆる関数は関数名を持ち、それはその関数が実行する作業を形容します。ある関数を使うためには、あなたはその関数をそれの名前を使って「呼び出し」、それにその関数のパラメータの型に適合する入力値（引数として知られます）を渡します。関数の引数は、常にその関数のパラメータ一覧と同じ順序で提供されなければなりません。

The function in the example below is called greet(person:), because that’s what it does—it takes a person’s name as input and returns a greeting for that person. To accomplish this, you define one input parameter—a String value called person—and a return type of String, which will contain a greeting for that person: 下記の例の関数は、それがすることから、greet(person:)と呼ばれます ― それは、入力としてある人の名前をとって、その人のために挨拶を返します。これを達成するために、あなたは１つの入力パラメータ ― personと呼ばれるString値 ― そしてその人のための挨拶を含むことになる、Stringの戻り型を定義します：

  1. func greet(person: String) -> String {
  2. let greeting = "Hello, " + person + "!"
  3. return greeting
  4. }

All of this information is rolled up into the function’s definition, which is prefixed with the func keyword. You indicate the function’s return type with the return arrow -> (a hyphen followed by a right angle bracket), which is followed by the name of the type to return. この情報の全ては、funcキーワードを前に置かれる、関数の定義にまとめ上げられます。あなたは、関数の戻り型を、戻り矢印 ->（ハイフンに続けて右の山形括弧）、それに続く返す型の名前で示します。

The definition describes what the function does, what it expects to receive, and what it returns when it’s done. The definition makes it easy for the function to be called unambiguously from elsewhere in your code: 定義は、関数が何をするか、それが何を受け取るのを予想するか、そしてそれが実行し終わったとき、それが何を返すかを記述します。定義は、関数があなたのコードのどこか他の場所から誤解の余地なく呼び出されることを簡単にします：

  1. print(greet(person: "Anna"))
  2. // Prints "Hello, Anna!"（「こんにちは、アンナ！」を出力します）
  3. print(greet(person: "Brian"))
  4. // Prints "Hello, Brian!"（「こんにちは、ブライアン！」を出力します）

You call the greet(person:) function by passing it a String value after the person argument label, such as greet(person: "Anna"). Because the function returns a String value, greet(person:) can be wrapped in a call to the print(_:separator:terminator:) function to print that string and see its return value, as shown above. あなたは、greet(person:)関数をそれにString値をperson引数ラベルの後で渡すことによって、例えばgreet(person: "Anna")のように呼び出します。この関数はString値を返すので、上で見られるように、greet(person:)はprint(_:separator:terminator:)関数への呼び出しの中に包まれて、その文字列を出力してその戻り値を見ることができます。

Note 注意

The print(_:separator:terminator:) function doesn’t have a label for its first argument, and its other arguments are optional because they have a default value. These variations on function syntax are discussed below in Function Argument Labels and Parameter Names and Default Parameter Values. print(_:separator:terminator:)関数は、それの最初の引数に対してラベルを持ちません、そしてそれの他の引数は任意です、それらが省略時の値を持つからです。関数構文上のこれらの差異は、関数の引数ラベルとパラメータ名と省略時のパラメータ値の下で議論されます。

The body of the greet(person:) function starts by defining a new String constant called greeting and setting it to a simple greeting message. This greeting is then passed back out of the function using the return keyword. In the line of code that says return greeting, the function finishes its execution and returns the current value of greeting. greet(person:)関数の本文は、greetingと呼ばれる新しいString定数を定義してそれを単純な挨拶メッセージに設定することによって始まります。この挨拶は、それからreturnキーワードを使用して逆に関数の外に渡されます。return greetingを告げるコード行において、関数はその実行を終えてgreetingの現在の値を返します。

You can call the greet(person:) function multiple times with different input values. The example above shows what happens if it’s called with an input value of "Anna", and an input value of "Brian". The function returns a tailored greeting in each case. あなたは、異なる入力値を使ってgreet(person:)関数を複数回呼び出すことができます。上の例は、それが"Anna"の入力値、そして"Brian"の入力値で呼ばれるならば、何が起こるかについて示します。関数は、それぞれの状況に合った挨拶を返します。

To make the body of this function shorter, you can combine the message creation and the return statement into one line: この関数の本文をより短くするために、あなたはメッセージ作成と返しの文を１行に結合することができます：

  1. func greetAgain(person: String) -> String {
  2. return "Hello again, " + person + "!"
  3. }
  4. print(greetAgain(person: "Anna"))
  5. // Prints "Hello again, Anna!"（「またあったね、アンナ！」を出力します）

Function Parameters and Return Values 関数のパラメータと戻り値

Function parameters and return values are extremely flexible in Swift. You can define anything from a simple utility function with a single unnamed parameter to a complex function with expressive parameter names and different parameter options. 関数パラメータと戻り値は、スウィフトではとても柔軟です。あなたは、ただ１つの無名のパラメータを持つ単純で便利な支援関数から、表現豊かなパラメータ名と種々のパラメータ・オプションを持つ複雑な関数まで何でも定義することができます。

Functions Without Parameters パラメータのない関数

Functions aren’t required to define input parameters. Here’s a function with no input parameters, which always returns the same String message whenever it’s called: 関数は、入力パラメータを定義することを要求されません。ここに入力パラメータのない関数があります、そしてそれは、それが呼ばれるときはいつでも、常に同じStringメッセージを返します：

  1. func sayHelloWorld() -> String {
  2. return "hello, world"
  3. }
  4. print(sayHelloWorld())
  5. // Prints "hello, world"（「よろしく、世界」を出力ます）

The function definition still needs parentheses after the function’s name, even though it doesn’t take any parameters. The function name is also followed by an empty pair of parentheses when the function is called. たとえそれが全くパラメータをとらないとしても、関数定義は依然として関数の名前の後に丸括弧を必要とします。その関数が呼ばれるとき、関数名の後にまた空の丸括弧の対が続きます。

Functions With Multiple Parameters 複数のパラメーターを持つ関数

Functions can have multiple input parameters, which are written within the function’s parentheses, separated by commas. 関数は複数の入力パラメータを持つことが出来ます、それは関数の丸括弧内に書かれ、コンマで区切られます。

This function takes a person’s name and whether they have already been greeted as input, and returns an appropriate greeting for that person: この関数は、人物の名前と彼らがすでに挨拶されたかどうかを入力として取って、ふさわしい挨拶をその人物に対して返します：

  1. func greet(person: String, alreadyGreeted: Bool) -> String {
  2. if alreadyGreeted {
  3. return greetAgain(person: person)
  4. } else {
  5. return greet(person: person)
  6. }
  7. }
  8. print(greet(person: "Tim", alreadyGreeted: true))
  9. // Prints "Hello again, Tim!"（「またあったね、ティム！」を出力します）

You call the greet(person:alreadyGreeted:) function by passing it both a String argument value labeled person and a Bool argument value labeled alreadyGreeted in parentheses, separated by commas. Note that this function is distinct from the greet(person:) function shown in an earlier section. Although both functions have names that begin with greet, the greet(person:alreadyGreeted:) function takes two arguments but the greet(person:) function takes only one. あなたはgreet(person:alreadyGreeted:)関数をそれにpersonでラベルしたString引数値とalreadyGreetedでラベルしたBool引き数値を両方とも丸括弧内に、コンマで区切って渡すことで呼び出します。この関数が前の節で見せたgreet(person:)関数と別個のものであることに注意してください。両方の関数がgreetで始まる名前を持つとはいえ、greet(person:alreadyGreeted:)関数は２つの引数を取りますがgreet(person:)関数はただ１つだけ取ります。

Functions Without Return Values 戻り値のない関数

Functions aren’t required to define a return type. Here’s a version of the greet(person:) function, which prints its own String value rather than returning it: 関数は、戻り型を定義することを要求されません。ここにgreet(person:)関数の改作があります、それはString値を自身で出力します、それを返すのではなく：

  1. func greet(person: String) {
  2. print("Hello, \(person)!")
  3. }
  4. greet(person: "Dave")
  5. // Prints "Hello, Dave!"

Because it doesn’t need to return a value, the function’s definition doesn’t include the return arrow (->) or a return type. それが値を返す必要がないので、この関数の定義は戻り矢印（->）または戻り型を含みません。

Note 注意

Strictly speaking, this version of the greet(person:) function does still return a value, even though no return value is defined. Functions without a defined return type return a special value of type Void. This is simply an empty tuple, which is written as (). 厳密に言って、たとえ戻り値が定義されないとしても、このバージョンのgreet(person:)関数は、まだ値を返します。戻り型定義のない関数は、型Voidの特別な値を返します。これは単に空のタプルです、それは()のように書かれます。

The return value of a function can be ignored when it’s called: 関数の戻り値は、それが呼ばれるとき無視されることができます：

  1. func printAndCount(string: String) -> Int {
  2. print(string)
  3. return string.count
  4. }
  5. func printWithoutCounting(string: String) {
  6. let _ = printAndCount(string: string)
  7. }
  8. printAndCount(string: "hello, world")
  9. // prints "hello, world" and returns a value of 12（「よろしく、世界」を出力して値12を返します）
  10. printWithoutCounting(string: "hello, world")
  11. // prints "hello, world" but doesn't return a value（「よろしく、世界」を出力しますが値を返しません）

The first function, printAndCount(string:), prints a string, and then returns its character count as an Int. The second function, printWithoutCounting(string:), calls the first function, but ignores its return value. When the second function is called, the message is still printed by the first function, but the returned value isn’t used. 最初の関数、printAndCount(string:)は、ある文字列を出力して、それからその文字数をIntとして返します。第二の関数、printWithoutCounting(string:)は、最初の関数を呼びます、しかしその戻り値を無視します。第二の関数が呼ばれるとき、メッセージは最初の関数によって依然として出力されます、しかし返された値は使われません。

Note 注意

Return values can be ignored, but a function that says it will return a value must always do so. A function with a defined return type can’t allow control to fall out of the bottom of the function without returning a value, and attempting to do so will result in a compile-time error. 戻り値は無視されることができます、しかし値を返すつもりだと言う関数は、常にそうしなければなりません。ある定義された戻り型を持つ関数は、値を返すことなく関数の底を抜け落ちるように制御されることができません、そしてそうしようとすることはコンパイル時エラーに終わります。

Functions with Multiple Return Values 複数の戻り値を持つ関数

You can use a tuple type as the return type for a function to return multiple values as part of one compound return value. あなたは、関数の戻り型としてタプル型を使って、複数の値をひとつの複合の戻り値の一部として返すことができます。

The example below defines a function called minMax(array:), which finds the smallest and largest numbers in an array of Int values: 下の例はminMax(array:)と呼ばれる関数を定義します、それは、あるInt値の配列の中で最小および最大の数を見つけます：

  1. func minMax(array: [Int]) -> (min: Int, max: Int) {
  2. var currentMin = array[0]
  3. var currentMax = array[0]
  4. for value in array[1..<array.count] {
  5. if value < currentMin {
  6. currentMin = value
  7. } else if value > currentMax {
  8. currentMax = value
  9. }
  10. }
  11. return (currentMin, currentMax)
  12. }

The minMax(array:) function returns a tuple containing two Int values. These values are labeled min and max so that they can be accessed by name when querying the function’s return value. minMax(array:)関数は、２つのInt値を含んでいる１つのタプルを返します。それらの値は、minおよびmaxとラベルをつけられます、なのでそれらはこの関数の戻り値について問い合わせるときに名前によってアクセスされることが出来ます。

The body of the minMax(array:) function starts by setting two working variables called currentMin and currentMax to the value of the first integer in the array. The function then iterates over the remaining values in the array and checks each value to see if it’s smaller or larger than the values of currentMin and currentMax respectively. Finally, the overall minimum and maximum values are returned as a tuple of two Int values. minMax(array:)の本文は、currentMinとcurrentMaxと呼ばれる２つの作業用の変数を配列の最初の整数に設定することによって始まります。この関数はそれから、配列の残りの値すべてに渡って繰り返します、そして各値をそれがcurrentMinおよびcurrentMaxの値より小さいかより大きいかそれぞれについて調べます。最後に、全体で最も小さいそして最も大きい値が２つのInt値のタプルとして返されます。

Because the tuple’s member values are named as part of the function’s return type, they can be accessed with dot syntax to retrieve the minimum and maximum found values: タプルの構成要素値は、この関数の戻り型の部分で命名されるので、それらは最小および最大の見つけられた値を取り出すためにドット構文でアクセスされることが出来ます。

  1. let bounds = minMax(array: [8, -6, 2, 109, 3, 71])
  2. print("min is \(bounds.min) and max is \(bounds.max)")
  3. // Prints "min is -6 and max is 109"（「最小は-6で、最大は109です」を出力します）

Note that the tuple’s members don’t need to be named at the point that the tuple is returned from the function, because their names are already specified as part of the function’s return type. タプルの構成要素が、タプルがその関数から返される時点で名前をつけられる必要がない点に注意してください、なぜなら、それらの名前が関数の戻り型の一部としてすでに指定されるからです。

Optional Tuple Return Types オプショナルタプルの戻り型

If the tuple type to be returned from a function has the potential to have “no value” for the entire tuple, you can use an optional tuple return type to reflect the fact that the entire tuple can be nil. You write an optional tuple return type by placing a question mark after the tuple type’s closing parenthesis, such as (Int, Int)? or (String, Int, Bool)?. ある関数から返されるタプル型がタプル全体として「値がない」見込みがあるならば、あなたはタプル全体がnilであることが出来るのを反映するためにオプショナルタプルの戻り型を使うことが出来ます。あなたはオプショナルタプルの戻り型をタプル型の閉じ括弧の後に疑問符を置くことによって書きます、例えば(Int, Int)?または(String, Int, Bool)?など。

Note 注意

An optional tuple type such as (Int, Int)? is different from a tuple that contains optional types such as (Int?, Int?). With an optional tuple type, the entire tuple is optional, not just each individual value within the tuple. (Int, Int)?のようなオプショナルタプル型は、(Int?, Int?)のようなオプショナル型を含むタプルとは異なる方式です。オプショナルタプル型では、タプル全体がオプショナルです、単にタプルの内部の個々の値それぞれではありません。

The minMax(array:) function above returns a tuple containing two Int values. However, the function doesn’t perform any safety checks on the array it’s passed. If the array argument contains an empty array, the minMax(array:) function, as defined above, will trigger a runtime error when attempting to access array[0]. 上のminMax(array:)関数は、２つのInt値を含んでいるタプルを返します。しかし、この関数は、それが渡される配列に関してどんな安全確認も実行しません。array引数が空の配列を含んでいるならば、上で定義されるminMax(array:)関数は、array[0]にアクセスしようとする時に実行時エラーを引き起こします。

To handle an empty array safely, write the minMax(array:) function with an optional tuple return type and return a value of nil when the array is empty: 空の配列を安全に取り扱うために、minMax(array:)関数をオプショナルタプルの戻り型を使って書いて、配列が空の時にnilの値を返してください：

  1. func minMax(array: [Int]) -> (min: Int, max: Int)? {
  2. if array.isEmpty { return nil }
  3. var currentMin = array[0]
  4. var currentMax = array[0]
  5. for value in array[1..<array.count] {
  6. if value < currentMin {
  7. currentMin = value
  8. } else if value > currentMax {
  9. currentMax = value
  10. }
  11. }
  12. return (currentMin, currentMax)
  13. }

You can use optional binding to check whether this version of the minMax(array:) function returns an actual tuple value or nil: あなたは、minMax(array:)関数のこの改作が返すのは本当のタプルなのかまたはnilなのかを調べるためにオプショナル束縛を使うことが出来ます：

  1. if let bounds = minMax(array: [8, -6, 2, 109, 3, 71]) {
  2. print("min is \(bounds.min) and max is \(bounds.max)")
  3. }
  4. // Prints "min is -6 and max is 109"（「最小は-6で、最大は109です」を出力します）

Functions With an Implicit Return 暗黙的なreturnをもつ関数

If the entire body of the function is a single expression, the function implicitly returns that expression. For example, both functions below have the same behavior: 関数の本文全体がある単一の式であるならば、その関数は暗黙的にその式を返します。例えば、下の両方の関数は同じ挙動を持ちます：

  1. func greeting(for person: String) -> String {
  2. "Hello, " + person + "!"
  3. }
  4. print(greeting(for: "Dave"))
  5. // Prints "Hello, Dave!"
  7. func anotherGreeting(for person: String) -> String {
  8. return "Hello, " + person + "!"
  9. }
  10. print(anotherGreeting(for: "Dave"))
  11. // Prints "Hello, Dave!"

The entire definition of the greeting(for:) function is the greeting message that it returns, which means it can use this shorter form. The anotherGreeting(for:) function returns the same greeting message, using the return keyword like a longer function. Any function that you write as just one return line can omit the return. greeting(for:)関数の全体の定義は、それが返す挨拶メッセージです、それは、それがこの省略形を使用できるのを意味します。anotherGreeting(for:)関数は、同じ挨拶メッセージを返します、もっと長い関数のようにreturnキーワードを使って。あなたがただ１つだけのreturn行として書くあらゆる関数は、returnを省略できます。

As you’ll see in Shorthand Getter Declaration, property getters can also use an implicit return. あなたが略記ゲッター宣言で見るように、プロパティゲッターもまた暗黙的なreturnを使用できます。

Note 注意

The code you write as an implicit return value needs to return some value. For example, you can’t use print(13) as an implicit return value. However, you can use a function that never returns like fatalError("Oh no!") as an implicit return value, because Swift knows that the implicit return doesn’t happen. あなたが暗黙的戻り値として書くコードは、何らかの値を返す必要があります。例えば、あなたはprint(13)を暗黙的戻り値として使用することはできません。しかしながら、あなたは決して復帰しない関数、たとえばfatalError("Oh no!")を暗黙的戻り値として使用できます、なぜならスウィフトは暗黙的戻り値が生じないことがわかるからです。

Function Argument Labels and Parameter Names 関数の引数ラベルとパラメータ名

Each function parameter has both an argument label and a parameter name. The argument label is used when calling the function; each argument is written in the function call with its argument label before it. The parameter name is used in the implementation of the function. By default, parameters use their parameter name as their argument label. 関数パラメーターそれぞれは、引数ラベルとパラメーター名の両方を持ちます。引数ラベルは、関数を呼び出すときに使われます；各引数は、関数呼び出しにおいてそれの前のそれの引数ラベルとともに書かれます。パラメータ名は、関数の実装内において使われます。特に何もしなければ、パラメータはそれらのパラメータ名をそれらの引数ラベルとして使います。

  1. func someFunction(firstParameterName: Int, secondParameterName: Int) {
  2. // In the function body, firstParameterName and secondParameterName（関数本文において、firstParameterNameとsecondParameterNameは、）
  3. // refer to the argument values for the first and second parameters.（最初と２番目のパラメーターに対する引き数の値を参照します。）
  4. }
  5. someFunction(firstParameterName: 1, secondParameterName: 2)

All parameters must have unique names. Although it’s possible for multiple parameters to have the same argument label, unique argument labels help make your code more readable. すべてのパラメーターは、特有な名前を持たなければなりません。複数のパラメータが同じ引数ラベルを持つことは可能であるとは言え、特有な引数ラベルはあなたのコードをより読みやすくする助けとなります。

Specifying Argument Labels 引数ラベルを指定する

You write an argument label before the parameter name, separated by a space: あなたは引数ラベルを、パラメーター名の前に、空白で区切って書きます：

  1. func someFunction(argumentLabel parameterName: Int) {
  2. // In the function body, parameterName refers to the argument value（関数本文において、parameterNameは）
  3. // for that parameter.（そのパラメータのための引数値に言及することができます。）
  4. }

Here’s a variation of the greet(person:) function that takes a person’s name and hometown and returns a greeting: ここにgreet(person:)関数の変形があります、それはある個人の名前と出身地をとって挨拶を返します：

  1. func greet(person: String, from hometown: String) -> String {
  2. return "Hello \(person)! Glad you could visit from \(hometown)."
  3. }
  4. print(greet(person: "Bill", from: "Cupertino"))
  5. // Prints "Hello Bill! Glad you could visit from Cupertino."

The use of argument labels can allow a function to be called in an expressive, sentence-like manner, while still providing a function body that’s readable and clear in intent. 引数ラベルの使用は、関数が、表現が豊かな、文章のようなやり方で呼び出されることを可能にします、その一方で、依然として読みやすくて意図が明白な関数本文を提供します。

Omitting Argument Labels 引数ラベルの省略

If you don’t want an argument label for a parameter, write an underscore (_) instead of an explicit argument label for that parameter. あなたがあるパラメーターに引数ラベルを使うことを望まないならば、そのパラメーターに対して明示的な引数ラベルの代わりにひとつのアンダースコア（_）を書いてください。

  1. func someFunction(_ firstParameterName: Int, secondParameterName: Int) {
  2. // In the function body, firstParameterName and secondParameterName（関数本文において、firstParameterNameとsecondParameterNameは、）
  3. // refer to the argument values for the first and second parameters.（最初と２番目のパラメーターに対する引き数の値を参照します。）
  4. }
  5. someFunction(1, secondParameterName: 2)

If a parameter has an argument label, the argument must be labeled when you call the function. ある引数が引数ラベルを持つならば、その引数は、あなたがその関数を呼ぶ時にラベルを付けられる必要があります。

Default Parameter Values 省略時のパラメータ値

You can define a default value for any parameter in a function by assigning a value to the parameter after that parameter’s type. If a default value is defined, you can omit that parameter when calling the function. あなたは、ある関数のすべてのパラメータに対して省略時の値を定義することが、そのパラメーターの型の後でパラメーターに値を割り当てることによって可能です。省略時の値が定義されるならば、あなたは関数を呼ぶときそのパラメータを省略することができます。

  1. func someFunction(parameterWithoutDefault: Int, parameterWithDefault: Int = 12) {
  2. // If you omit the second argument when calling this function, then（あなたが２番目の引数をこの関数を呼び出すときに省略したならば、その時）
  3. // the value of parameterWithDefault is 12 inside the function body.（parameterWithDefaultの値はこの関数本文の内部で12です。）
  4. }
  5. someFunction(parameterWithoutDefault: 3, parameterWithDefault: 6) // parameterWithDefault is 6
  6. someFunction(parameterWithoutDefault: 4) // parameterWithDefault is 12

Place parameters that don’t have default values at the beginning of a function’s parameter list, before the parameters that have default values. Parameters that don’t have default values are usually more important to the function’s meaning—writing them first makes it easier to recognize that the same function is being called, regardless of whether any default parameters are omitted. 省略時の値を持たないパラメータを関数のもつパラメータリストの始まりに、省略時の値を持つパラメータの前に、置いてください。省略時の値を持たないパラメータは、関数の意味するところにとって通常より重要です—それらを最初に書くことは、何らかの省略時のパラメータが省かれているかどうかに関係なく、同じ関数が呼び出されているのをよりわかり易くします。

Variadic Parameters 可変長パラメータ

A variadic parameter accepts zero or more values of a specified type. You use a variadic parameter to specify that the parameter can be passed a varying number of input values when the function is called. Write variadic parameters by inserting three period characters (...) after the parameter’s type name. 可変長パラメータは、指定された型の０個以上の値を受け取ります。あなたは可変長パラメータを、関数が呼ばれる時にそのパラメータが変動する数の入力値を渡されることができることを示すために使います。そのパラメータの型名の後に３つのピリオド文字（...）を書き入れることによって、可変長パラメータを書いてください。

The values passed to a variadic parameter are made available within the function’s body as an array of the appropriate type. For example, a variadic parameter with a name of numbers and a type of Double... is made available within the function’s body as a constant array called numbers of type [Double]. 可変長パラメータに渡される値は、適切な型の配列として、関数の本文内で利用可能にされます。例えば、numbersの名前とDouble...の型を持つある可変長パラメータは、関数の本文内で型[Double]のnumbersと呼ばれるある定数配列として利用可能にされます。

The example below calculates the arithmetic mean (also known as the average) for a list of numbers of any length: 下の例は、どんな長さの数のリストに対しても、算術平均（また平均としても知られるもの）を計算します：

  1. func arithmeticMean(_ numbers: Double...) -> Double {
  2. var total: Double = 0
  3. for number in numbers {
  4. total += number
  5. }
  6. return total / Double(numbers.count)
  7. }
  8. arithmeticMean(1, 2, 3, 4, 5)
  9. // returns 3.0, which is the arithmetic mean of these five numbers（3.0を返します、それはこれら５つの数の算術平均です）
  10. arithmeticMean(3, 8.25, 18.75)
  11. // returns 10.0, which is the arithmetic mean of these three numbers（10.0を返します、それはこれら３つの数の算術平均です）

A function can have multiple variadic parameters. The first parameter that comes after a variadic parameter must have an argument label. The argument label makes it unambiguous which arguments are passed to the variadic parameter and which arguments are passed to the parameters that come after the variadic parameter. 関数は、複数の可変長パラメータを持つことができます。ある可変長パラメータの後にくる最初のパラメータは、引数ラベルを持たなければなりません。引数ラベルは、可変長パラメータに渡される引数はどれか、そして可変長パラメータの後に来るパラメータに渡される引数はどれかを明白にします。

In-Out Parameters In-Outパラメータ

Function parameters are constants by default. Trying to change the value of a function parameter from within the body of that function results in a compile-time error. This means that you can’t change the value of a parameter by mistake. If you want a function to modify a parameter’s value, and you want those changes to persist after the function call has ended, define that parameter as an in-out parameter instead. 関数パラメータは、特に何もしなければ定数です。その関数の本文内部から関数パラメータの値を変えようとすることは、コンパイル時エラーに終わります。これは、あなたが誤ってパラメータの値を変えることができないことを意味します。あなたがある関数にパラメータの値を修正して欲しいならば、そしてあなたが関数呼び出しが終わった後それらの変化に存続して欲しいならば、代わりにそのパラメータをin-outパラメータとして定義してください。

You write an in-out parameter by placing the inout keyword right before a parameter’s type. An in-out parameter has a value that’s passed in to the function, is modified by the function, and is passed back out of the function to replace the original value. For a detailed discussion of the behavior of in-out parameters and associated compiler optimizations, see In-Out Parameters. あなたは、パラメータの型のすぐ前にinoutキーワードを置くことによってin-outパラメータを書きます。in-outパラメータはある値を持ち、それは関数の中に渡されて、その関数によって修正されて、それから逆にその関数の外に渡されて本来の値に取って代わります。in-outパラメータの挙動と関連するコンパイラ最適化の詳細な議論として、in-outパラメータを見てください。

You can only pass a variable as the argument for an in-out parameter. You can’t pass a constant or a literal value as the argument, because constants and literals can’t be modified. You place an ampersand (&) directly before a variable’s name when you pass it as an argument to an in-out parameter, to indicate that it can be modified by the function. あなたは、in-outパラメータに対する引数として、変数を渡すことだけができます。あなたは引数として定数またはリテラル値を渡すことができません、なぜなら定数とリテラルは修正されることができないからです。あなたは変数の名前の直前に、あなたがin-outパラメータに対する引数としてそれを渡すときに、それが関数によって修正されることができることを示すために、アンパサンド（&）を置きます。

Note 注意

In-out parameters can’t have default values, and variadic parameters can’t be marked as inout. In-outパラメータは省略時の値を持つことができません、そして可変長パラメータはinoutとして印されることができません。

Here’s an example of a function called swapTwoInts(_:_:), which has two in-out integer parameters called a and b: ここにswapTwoInts(_:_:)と呼ばれる関数の例があります、それは、aとbと呼ばれる２つのin-out整数パラメータを持ちます：

  1. func swapTwoInts(_ a: inout Int, _ b: inout Int) {
  2. let temporaryA = a
  3. a = b
  4. b = temporaryA
  5. }

The swapTwoInts(_:_:) function simply swaps the value of b into a, and the value of a into b. The function performs this swap by storing the value of a in a temporary constant called temporaryA, assigning the value of b to a, and then assigning temporaryA to b. swapTwoInts(_:_:)関数は、単にbの値をaの中に、そしてaの値をbの中へと入れ替えます。関数はこの交換を、aの値をtemporaryAと呼ばれる一時的な定数の中に格納して、bの値をaに代入して、それからtemporaryAをbに代入することによって実行します。

You can call the swapTwoInts(_:_:) function with two variables of type Int to swap their values. Note that the names of someInt and anotherInt are prefixed with an ampersand when they’re passed to the swapTwoInts(_:_:) function: あなたは、swapTwoInts(_:_:)関数を、それらの値を交換する２つのInt型の変数で呼ぶことができます。someIntとanotherIntの名前が、それらがswapTwoInts(_:_:)関数に渡される時に、アンパサンドで接頭辞を付けられるという点に注意してください：

  1. var someInt = 3
  2. var anotherInt = 107
  3. swapTwoInts(&someInt, &anotherInt)
  4. print("someInt is now \(someInt), and anotherInt is now \(anotherInt)")
  5. // Prints "someInt is now 107, and anotherInt is now 3"（「someIntは今は107、anotherIntは今は３です」を出力します）

The example above shows that the original values of someInt and anotherInt are modified by the swapTwoInts(_:_:) function, even though they were originally defined outside of the function. 上の例は、someIntとanotherIntの本来の値が、たとえそれらが元々は関数の外側で定義されたとしても、swapTwoInts(_:_:)関数によって修正されることを示します。

Note 注意

In-out parameters aren’t the same as returning a value from a function. The swapTwoInts example above doesn’t define a return type or return a value, but it still modifies the values of someInt and anotherInt. In-out parameters are an alternative way for a function to have an effect outside of the scope of its function body. in-outパラメータは、関数からある値が返されることと同じではありません。上のswapTwoInts例は、戻り型を定義しないし、また値を返しません、しかしそれでもそれはsomeIntとanotherIntの値を修正します。in-outパラメータは、その関数本体のスコープの外で効果を持つようにする関数のための代替の方法です。

Function Types 関数型

Every function has a specific function type, made up of the parameter types and the return type of the function. あらゆる関数は特定の関数型を持ちます、それは、その関数のパラメータ型と戻り型から成り立ちます。

For example: 例えば：

  1. func addTwoInts(_ a: Int, _ b: Int) -> Int {
  2. return a + b
  3. }
  4. func multiplyTwoInts(_ a: Int, _ b: Int) -> Int {
  5. return a * b
  6. }

This example defines two simple mathematical functions called addTwoInts and multiplyTwoInts. These functions each take two Int values, and return an Int value, which is the result of performing an appropriate mathematical operation. この例は、addTwoIntsとmultiplyTwoIntsと呼ばれる２つの単純な数学的な関数を定義します。これらの関数は、各々２つのInt値をとって、１つのInt値を返します、そしてそれは、適切な数値演算の実行の結果です。

The type of both of these functions is (Int, Int) -> Int. This can be read as: これらの関数の型は両方とも、(Int, Int) -> Intです。これは、次のように解釈されることができます：

“A function that has two parameters, both of type Int, and that returns a value of type Int.” 「２つのパラメータを持ち、両方とも型Intで、そして型Intの値をひとつ返す関数」

Here’s another example, for a function with no parameters or return value: もう１つの例がここにあります、パラメータおよび戻り値のないある関数です：

  1. func printHelloWorld() {
  2. print("hello, world")
  3. }

The type of this function is () -> Void, or “a function that has no parameters, and returns Void.” この関数の型は() -> Voidです、あるいは「パラメータを持たず、Voidを返す関数」。

Using Function Types 関数型を使う

You use function types just like any other types in Swift. For example, you can define a constant or variable to be of a function type and assign an appropriate function to that variable: あなたは、関数型をスウィフトでのあらゆる他の型と同じように使います。例えば、あなたはある関数型となる定数または変数を定義して、適切な関数をその変数に代入することができます：

  1. var mathFunction: (Int, Int) -> Int = addTwoInts

This can be read as: これは、次のように解釈されることができます：

“Define a variable called mathFunction, which has a type of ‘a function that takes two Int values, and returns an Int value.’ Set this new variable to refer to the function called addTwoInts.” 「『２つのInt値をとり、１つのInt値を返す関数』の型を持ち、mathFunctionと呼ばれる、ある変数を定義する。この新しい変数をaddTwoIntsと呼ばれる関数に言及するように設定する。」

The addTwoInts(_:_:) function has the same type as the mathFunction variable, and so this assignment is allowed by Swift’s type-checker. addTwoInts(_:_:)関数はmathFunction変数と同じ型を持ちます、なので、この代入はスウィフトの型チェッカーによって認められます。

You can now call the assigned function with the name mathFunction: あなたは、今や、代入された関数を名前mathFunctionを使って呼ぶことができます：

  1. print("Result: \(mathFunction(2, 3))")
  2. // Prints "Result: 5"（「結果：５」を出力します）

A different function with the same matching type can be assigned to the same variable, in the same way as for nonfunction types: 同じ適合型を持つ異なる関数は、同じ変数に代入されることが可能です、それは非関数型に対するのと同じ方法で行えます：

  1. mathFunction = multiplyTwoInts
  2. print("Result: \(mathFunction(2, 3))")
  3. // Prints "Result: 6"（「結果：６」を出力します）

As with any other type, you can leave it to Swift to infer the function type when you assign a function to a constant or variable: あらゆる他の型と同様に、あなたが関数を定数または変数に代入するとき、あなたはスウィフトに関数型を推論するように任せることができます：

  1. let anotherMathFunction = addTwoInts
  2. // anotherMathFunction is inferred to be of type (Int, Int) -> Int（anotherMathFunctionは、型(Int, Int) -> Intであると推論されます）

Function Types as Parameter Types パラメータ型としての関数型

You can use a function type such as (Int, Int) -> Int as a parameter type for another function. This enables you to leave some aspects of a function’s implementation for the function’s caller to provide when the function is called. あなたは、ある関数型、例えば(Int, Int) -> Intを、別の関数のためのパラメータ型として使うことができます。これはあなたに、ある関数の実装のいくつかの側面をその関数の呼び出し側のために、その関数が呼ばれるとき提供する目的で、取っておくことを可能にします。

Here’s an example to print the results of the math functions from above: ここに上記の数学関数の結果を出力する例があります：

  1. func printMathResult(_ mathFunction: (Int, Int) -> Int, _ a: Int, _ b: Int) {
  2. print("Result: \(mathFunction(a, b))")
  3. }
  4. printMathResult(addTwoInts, 3, 5)
  5. // Prints "Result: 8"（「結果：８」を出力します）

This example defines a function called printMathResult(_:_:_:), which has three parameters. The first parameter is called mathFunction, and is of type (Int, Int) -> Int. You can pass any function of that type as the argument for this first parameter. The second and third parameters are called a and b, and are both of type Int. These are used as the two input values for the provided math function. この例はprintMathResult(_:_:_:)と呼ばれる関数を定義します、それは３つのパラメータを持ちます。最初のパラメータはmathFunctionと呼ばれていて、型(Int, Int) -> Intです。あなたは、この最初のパラメータに対する引数として、その型のどんな関数でも渡すことができます。２番目と３番目のパラメータはaとbと呼ばれます、そして両方ともInt型です。これらは提供された数学関数のための２つの入力値として使われます。

When printMathResult(_:_:_:) is called, it’s passed the addTwoInts(_:_:) function, and the integer values 3 and 5. It calls the provided function with the values 3 and 5, and prints the result of 8. printMathResult(_:_:_:)が呼ばれるとき、それは、addTwoInts(_:_:)関数、そして整数値3と5を渡されます。それは、提供された関数を値3と5を使って呼び出して、結果の8を出力します。

The role of printMathResult(_:_:_:) is to print the result of a call to a math function of an appropriate type. It doesn’t matter what that function’s implementation actually does—it matters only that the function is of the correct type. This enables printMathResult(_:_:_:) to hand off some of its functionality to the caller of the function in a type-safe way. printMathResult(_:_:_:)の役割は、適切な型の数学関数に対する呼び出しの結果を出力することです。その関数の実装が実際に何をするかは、重要ではありません ― ただ関数が正しい型であるのが重要です。これは、printMathResult(_:_:_:)にその機能性の一部をその関数の呼び出し手に、ある型安全な方法で、手渡すことを可能にします。

Function Types as Return Types 戻り型としての関数型

You can use a function type as the return type of another function. You do this by writing a complete function type immediately after the return arrow (->) of the returning function. あなたは、ある関数型をそれとは違う関数の戻り型として使うことができます。あなたは、返すことになる関数の戻り矢印（->）の直後に完全な関数型を書くことによってこれをします。

The next example defines two simple functions called stepForward(_:) and stepBackward(_:). The stepForward(_:) function returns a value one more than its input value, and the stepBackward(_:) function returns a value one less than its input value. Both functions have a type of (Int) -> Int: 次の例は、stepForward(_:)とstepBackward(_:)と呼ばれる２つの単純な関数を定義します。stepForward(_:)関数は、その入力された値より１大きい値を返します、そしてstepBackward(_:)関数はその入力された値より１小さい値を返します。両方の関数は、(Int) -> Intの型を持ちます：

  1. func stepForward(_ input: Int) -> Int {
  2. return input + 1
  3. }
  4. func stepBackward(_ input: Int) -> Int {
  5. return input - 1
  6. }

Here’s a function called chooseStepFunction(backward:), whose return type is (Int) -> Int. The chooseStepFunction(backward:) function returns the stepForward(_:) function or the stepBackward(_:) function based on a Boolean parameter called backward: ここにchooseStepFunction(backward:)と呼ばれる関数があります、それの戻り型は(Int) -> Intです。chooseStepFunction(backward:)はstepForward(_:)関数あるいはstepBackward(_:)関数を、backwardと呼ばれるブールのパラメータに基づいて返します：

  1. func chooseStepFunction(backward: Bool) -> (Int) -> Int {
  2. return backward ? stepBackward : stepForward
  3. }

You can now use chooseStepFunction(backward:) to obtain a function that will step in one direction or the other: 現在あなたはchooseStepFunction(backward:)を使って、ある方向にまたはもう一方に進む関数を取得できます：

  1. var currentValue = 3
  2. let moveNearerToZero = chooseStepFunction(backward: currentValue > 0)
  3. // moveNearerToZero now refers to the stepBackward() function（moveNearerToZeroは、現在はstepBackward()関数に言及します）

The example above determines whether a positive or negative step is needed to move a variable called currentValue progressively closer to zero. currentValue has an initial value of 3, which means that currentValue > 0 returns true, causing chooseStepFunction(backward:) to return the stepBackward(_:) function. A reference to the returned function is stored in a constant called moveNearerToZero. 上の例は、currentValueと呼ばれる変数を次第にゼロにより近く動かすために正と負の一歩のどちらが必要とされるかを確定します。currentValueは3の初期値を持ちます、そしてそれは、currentValue > 0がtrueを返して、chooseStepFunction(backward:)がstepBackward(_:)関数を返すことを引き起こすのを意味します。返された関数への参照は、moveNearerToZeroと呼ばれる定数に格納されます。

Now that moveNearerToZero refers to the correct function, it can be used to count to zero: moveNearerToZeroが正しい関数に言及する今、それはゼロまで数えるために使われることができます：

  1. print("Counting to zero:")
  2. // Counting to zero:（「ゼロまで数えます：」）
  3. while currentValue != 0 {
  4. print("\(currentValue)... ")
  5. currentValue = moveNearerToZero(currentValue)
  6. }
  7. print("zero!")
  8. // 3...
  9. // 2...
  10. // 1...
  11. // zero!

Nested Functions 入れ子にされた関数

All of the functions you have encountered so far in this chapter have been examples of global functions, which are defined at a global scope. You can also define functions inside the bodies of other functions, known as nested functions. あなたがこの章においてこれまで遭遇した関数の全てはグローバルな関数の例でした、そしてそれは、グローバルなスコープで定義されます。あなたはまた、他の関数の本体の内側に関数を、入れ子にされた関数として知られるものを、定義することができます。

Nested functions are hidden from the outside world by default, but can still be called and used by their enclosing function. An enclosing function can also return one of its nested functions to allow the nested function to be used in another scope. 入れ子にされた関数は、初期状態では外界から隠されます、しかしそれにもかかわらず、それらを囲む関数によって呼び出されて使われることができます。囲んでいる関数は、また、入れ子にされた関数が別のスコープにおいて使われるのを許可するために、その入れ子にされた関数のうちの１つを返すことができます。

You can rewrite the chooseStepFunction(backward:) example above to use and return nested functions: あなたは、入れ子にされた関数を使用して返すように、上記のchooseStepFunction(backward:)の例を書き直すことができます：

  1. func chooseStepFunction(backward: Bool) -> (Int) -> Int {
  2. func stepForward(input: Int) -> Int { return input + 1 }
  3. func stepBackward(input: Int) -> Int { return input - 1 }
  4. return backward ? stepBackward : stepForward
  5. }
  6. var currentValue = -4
  7. let moveNearerToZero = chooseStepFunction(backward: currentValue > 0)
  8. // moveNearerToZero now refers to the nested stepForward() function（moveNearerToZeroは、現在は入れ子にされたstepForward()関数に言及します）
  9. while currentValue != 0 {
  10. print("\(currentValue)... ")
  11. currentValue = moveNearerToZero(currentValue)
  12. }
  13. print("zero!")
  14. // -4...
  15. // -3...
  16. // -2...
  17. // -1...
  18. // zero!

Control Flow 制御の流れ

Closures クロージャ