Swift Language
関数

基本的な使用

関数はパラメータや戻り値なしで宣言できます。唯一必要な情報は名前です（この場合はhello ）。

func hello()
{
    print("Hello World")
}

パラメタのない関数を呼び出すには、名前の後ろに括弧の空のペアを記述します。

hello()
//output: "Hello World"

パラメータを持つ関数

関数は、その機能を変更できるようにパラメータを取ることができます。パラメータは、型と名前が定義されたカンマ区切りのリストとして与えられます。

func magicNumber(number1: Int)
{
    print("\(number1) Is the magic number")
}

注意： \(number1)構文は基本的な文字列補間であり、文字列に整数を挿入するために使用されます。

関数を名前で指定し、関数宣言で使用される型の入力値を指定することにより、パラメータを持つ関数が呼び出されます。

magicNumber(5)
//output: "5 Is the magic number
let example: Int = 10
magicNumber(example)
//output: "10 Is the magic number"

Int型の値を使用できました。

func magicNumber(number1: Int, number2: Int)
{
    print("\(number1 + number2) Is the magic number")
}

ある関数が複数のパラメーターを使用する場合、最初のパラメーターの名前は最初のパラメーターの名前ではなく、後続のパラメーターになります。

let ten: Int = 10
let five: Int = 5
magicNumber(ten,number2: five)
//output: "15 Is the magic number"

関数呼び出しをより読みやすくするには、外部パラメータ名を使用します。

func magicNumber(one number1: Int, two number2: Int)
{
    print("\(number1 + number2) Is the magic number")
}

let ten: Int = 10
let five: Int = 5
magicNumber(one: ten, two: five)

関数宣言でデフォルト値を設定すると、入力値を与えずに関数を呼び出すことができます。

func magicNumber(one number1: Int = 5, two number2: Int = 10)
{
    print("\(number1 + number2) Is the magic number")
}

magicNumber()
//output: "15 Is the magic number"

戻り値

関数は、パラメータのリストの後に型を指定することによって値を返すことができます。

func findHypotenuse(a: Double, b: Double) -> Double
{
    return sqrt((a * a) + (b * b))
}

let c = findHypotenuse(3, b: 5)
//c = 5.830951894845301

関数は、タプルを使用して複数の値を返すこともできます。

func maths(number: Int) -> (times2: Int, times3: Int)
{
    let two = number * 2
    let three = number * 3
    return (two, three)
}
let resultTuple = maths(5)
//resultTuple = (10, 15)

投げるエラー

関数がエラーをスローできるようにするには、引数を保持するかっこの後にthrowsキーワードを追加する必要があります。

func errorThrower()throws -> String {}

エラーをスローするには、 throwキーワードを使用します。

func errorThrower()throws -> String {
  if true {
    return "True"
  } else {
    // Throwing an error
    throw Error.error 
  }
}

エラーが発生する可能性のある関数を呼び出す場合は、 doブロックでtryキーワードを使用する必要がdoます。

do {
  try errorThrower()
}

スウィフトエラーの詳細： エラー

メソッド

インスタンスメソッドは、Swift（ クラス 、 構造体 、 列挙型 、またはプロトコル ）の型のインスタンスに属する関数です。 型メソッドは型自体で呼び出されます。

インスタンスメソッド

インスタンスメソッドは、型定義内または拡張内のfunc宣言で定義されます。

class Counter {
    var count = 0
    func increment() {
        count += 1
    }
}

increment()インスタンスメソッドは、 Counterクラスのインスタンスで呼び出されます。

let counter = Counter()  // create an instance of Counter class   
counter.increment()      // call the instance method on this instance

型メソッド

型メソッドはstatic funcキーワードで定義されます。 （ class func 、 class funcはサブクラスによってオーバーライドできる型メソッドを定義します。）

class SomeClass {
    class func someTypeMethod() {
        // type method implementation goes here
    }
}

SomeClass.someTypeMethod()  // type method is called on the SomeClass type itself

入力パラメータ

関数は、 inoutキーワードでマークされている場合、渡されたパラメータを変更できます。 inoutパラメーターを関数に渡す場合、呼び出し元は渡される変数に&を追加する必要があります。

func updateFruit(fruit: inout Int) {
    fruit -= 1
}

var apples = 30 // Prints "There's 30 apples"
print("There's \(apples) apples")

updateFruit(fruit: &apples)

print("There's now \(apples) apples") // Prints "There's 29 apples".

これにより、通常は値セマンティクスを持つ型に参照セマンティクスを適用することができます。

トレーリングクロージャの構文

関数の最後のパラメータがクロージャであるとき

func loadData(id: String, completion:(result: String) -> ()) {
    // ...
    completion(result:"This is the result data")
}

Trailing Closure Syntaxを使用して関数を呼び出すことができます

loadData("123") { result in
    print(result)
}

演算子は関数です

+ 、 - 、 ??などの演算子文字ではなくシンボルを使って名前をつけた関数の一種です。それらは関数とは異なって呼び出されます：

• プレフィックス： - x
• インフィックス： x + y
• Postfix： x ++

The Swift Programming Languageの基本オペレータと上級オペレータの詳細については、こちらをご覧ください。

可変パラメータ

場合によっては、関数が必要とする可能性のあるパラメータの数を列挙することはできません。 sum関数を考えてみましょう：

func sum(_ a: Int, _ b: Int) -> Int {
    return a + b
}

これは2つの数の和を求めるのにうまくいきますが、3つの合計を求めるためには別の関数を書く必要があります：

func sum(_ a: Int, _ b: Int, _ c: Int) -> Int {
    return a + b + c
}

4つのパラメータを持つものは別のものを必要とするなどです。 Swiftでは、3つの期間のシーケンスを使用して、可変数のパラメータを持つ関数を定義することができ... 。例えば、

func sum(_ numbers: Int...) -> Int {
    return numbers.reduce(0, combine: +)
}

variadicであるnumbersパラメータが、 [Int]型の単一Arrayにどのように合体するかに注目してください。これは一般的に真であり、タイプT...可変パラメータは[T]としてアクセス可能である。

この関数は今ように呼び出すことができます：

let a = sum(1, 2) // a == 3
let b = sum(3, 4, 5, 6, 7) // b == 25

Swiftのvariadicパラメータは、パラメータリストの最後に来る必要はありませんが、各関数シグネチャには1つしか存在できません。

時々、パラメータの数に最小サイズを入れるのが便利です。たとえば、値のsumをとることは実際には意味がありません。これを実行する簡単な方法は、いくつかの非可変の必須パラメーターを入れてから、その後にvariadicパラメーターを追加することです。 sumは、少なくとも2つのパラメータでのみ呼び出すことができるように、

func sum(_ n1: Int, _ n2: Int, _ numbers: Int...) -> Int {
    return numbers.reduce(n1 + n2, combine: +)
}

sum(1, 2) // ok
sum(3, 4, 5, 6, 7) // ok
sum(1) // not ok
sum() // not ok

下付き文字

クラス、構造体、および列挙型は、コレクション、リスト、またはシーケンスのメンバ要素にアクセスするためのショートカットであるサブスクリプトを定義できます。

例

struct DaysOfWeek {
  
  var days = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]
  
  subscript(index: Int) -> String {
    get {
      return days[index]
    }
    set {
      days[index] = newValue
    }
  }
}

下付き文字の使用法

var week = DaysOfWeek()
//you access an element of an array at index by array[index].
debugPrint(week[1])
debugPrint(week[0])
week[0] = "Sunday"
debugPrint(week[0])

下付き文字オプション：

下付き文字は任意の数の入力パラメータを取ることができ、これらの入力パラメータは任意のタイプでよい。また、添字は任意の型を返すことができます。下付き文字は可変パラメータと可変パラメータを使用できますが、in-outパラメータを使用したり、デフォルトパラメータ値を提供することはできません。

例：

struct Food {
  
  enum MealTime {
    case Breakfast, Lunch, Dinner
  }
  
  var meals: [MealTime: String] = [:]
  
  subscript (type: MealTime) -> String? {
    get {
      return meals[type]
    }
    set {
      meals[type] = newValue
    }
  }
}

使用法

var diet = Food()
diet[.Breakfast] = "Scrambled Eggs"
diet[.Lunch] = "Rice"

debugPrint("I had \(diet[.Breakfast]) for breakfast")

クロージャ付き関数

クロージャを受け入れて実行する関数を使うことは、他の場所で実行されるコードブロックを送信するのに非常に便利です。私たちは、関数が（この場合は） Void返すオプションのクロージャーを取り入れることから始めることができます。

func closedFunc(block: (()->Void)? = nil) {
    print("Just beginning")

    if let block = block {
        block()
    }
}

関数が定義されたので、それを呼び出してコードを渡しましょう：

closedFunc() { Void in
    print("Over already")
}

関数呼び出しで末尾のクロージャを使用することで、 closedFunc()関数内のある時点で実行されるコード（この場合はprint ）を渡すことができます。

ログは次のように出力されます。

始まったばかり

すでに

これのより具体的な使用例には、2つのクラス間のコードの実行が含まれます。

class ViewController: UIViewController {

    override func viewDidLoad() {
        let _  = A.init(){Void in self.action(2)}
    }

    func action(i: Int) {
        print(i)
    }
}


class A: NSObject {
    var closure : ()?

    init(closure: (()->Void)? = nil) {
        // Notice how this is executed before the  closure
        print("1")
        // Make sure closure isn't nil
        self.closure = closure?()
    }
}

ログは次のように出力されます。

1

2

関数の受け渡しと戻り

次の関数は、後で変数に代入して呼び出すことができる別の関数を結果として返します。

func jediTrainer () -> ((String, Int) -> String) {
  func train(name: String, times: Int) -> (String) {
    return "\(name) has been trained in the Force \(times) times"
  }
  return train
}

let train = jediTrainer()
train("Obi Wan", 3)

関数型

すべての関数には、パラメータ型と関数自体の戻り値の型からなる独自の関数型があります。たとえば、次の関数：

func sum(x: Int, y: Int) -> (result: Int) { return x + y }

関数の型は次のとおりです。

(Int, Int) -> (Int)

したがって、関数型は、パラメータ型として、またはネスト関数の戻り値の型として使用できます。