スウィフト – ファンクション

関数とは、特定のタスクを実行するためにまとめられた一連の文です。Swift 4関数は、単純なC関数をObjective C言語関数のように使うことができます。これにより、関数呼び出しの中でローカルおよびグローバルのパラメータ値を渡すことができます。

関数宣言 – 関数の名前、戻り値の型、およびパラメータについてコンパイラに指示します。
関数定義 – 関数の実際の本体を提供します。

Swift 4関数には、パラメータ型とその戻り型が含まれています。

関数定義

Swift 4では、関数は “func”キーワードで定義されます。ある関数が新たに定義されると、関数への入力パラメータとして1つまたは複数の値をとり、本体の関数を処理し、その値を出力 ‘戻り値の型’として関数に渡します。

すべての関数には関数名があり、関数が実行するタスクを記述します。関数を使用するには、その関数を名前で呼び出すとともに、関数のパラメータの型に一致する入力値（引数）を渡します。関数パラメータは「タプル」とも呼ばれます。

関数の引数は、常に関数のパラメータリストと同じ順序で指定しなければならず、戻り値の後に→が続きます。

構文

func funcname(Parameters) -> returntype {
   Statement1
   Statement2
   ---
   Statement N
   return parameters
}

次のコードを見てください。生徒の名前は、関数 ‘student’の中で宣言された文字列型として宣言され、関数が呼び出されると、生徒の名前が返されます。

func student(name: String) -> String {
   return name
}

print(student(name: "First Program"))
print(student(name: "About Functions"))

PLAYGROUNDで実行すると以下のようになります

First Program
About Functions

関数の呼び出し

‘display’という関数を定義し、関数名 ‘display’が整数データ型を保持する引数 ‘no1’で最初に初期化された関数を数値表示することを考えてみましょう。

引き数 ‘no1’が引き数 ‘a’に割り当てられ、以後同じデータ型整数を指します。引数 ‘a’が関数に返されます。display（）関数は整数値を保持し、関数が呼び出されるたびに整数値を返します。

func display(no1: Int) -> Int {
   let a = no1
   return a
}

print(display(no1: 100))
print(display(no1: 200))

PPLAYGROUNDで実行すると以下のようになります

100
200

パラメータと戻り値

Swift 4は、柔軟な関数パラメータとその戻り値を簡単な値から複雑な値に提供します。CとObjective Cの場合と同様に、Swift 4の関数もいくつかの形式をとります。

パラメータを持つ関数

関数内のタプルとして複数のパラメータ値を1つまたは複数に渡すことができます。

func mult(no1: Int, no2: Int) -> Int {
   return no1*no2
}

print(mult(no1: 2, no2: 20))
print(mult(no1: 3, no2: 15))
print(mult(no1: 4, no2: 30))

PLAYGROUNDで実行すると以下になります

40
45
120

パラメータなしの関数

また、パラメータを持たない関数もあります。

構文

func funcname() -> datatype {
   return datatype
}

以下は、パラメータなしの関数を持つ例です。

func votersname() -> String {
   return "Alice"
}
print(votersname())

PLAYGROUNDで実行すると以下のようになります。

Alice

戻り値を持つ関数

関数は、戻り値の型として文字列、整数、および浮動小数点データ型の値を返すためにも使用されます。

与えられた配列関数の中で最大のものと最小のものを見つけるために、以下’ls’は大小の整数データ型で宣言されています。

配列は整数値を保持するように初期化されます。その後、配列が処理され、配列内のすべての値が読み取られ、前の値と比較されます。

値が前の値よりも小さい場合、それは ‘small’引数に格納されます。そうでない場合、 ‘large’引数に格納され、関数を呼び出すことによって値が返されます。

func ls(array: [Int]) -> (large: Int, small: Int) {
   var lar = array[0]
   var sma = array[0]

   for i in array[1..<array.count] {
      if i < sma {
         sma = i
      } else if i > lar {
         lar = i
      }
   }
   return (lar, sma)
}

let num = ls(array: [40,12,-5,78,98])
print("Largest number is: \(num.large) and smallest number is: \(num.small)")

PLAYGROUDで実行すると以下のようになります

Largest number is: 98 and smallest number is: -5

戻り値のない関数

関数の中には、戻り値のない関数内で宣言された引数を持つものがあります。次のプログラムは、sum（）関数の引数としてaとbを宣言しています。

関数自体の中で、引数aとbの値は関数呼び出しsum（）を呼び出して渡され、その値が出力されて戻り値が取り除かれます。

func sum(a: Int, b: Int) {
   let a = a + b
   let b = a - b
   print(a, b)
}

sum(a: 20, b: 10)
sum(a: 40, b: 10)
sum(a: 24, b: 6)

私たちが上記のプログラムを遊び場で実行すると、次の結果が得られます。

30 20
50 40
30 24

オプションの戻り値型を持つ関数

Swift 4は、問題を解決するための「オプション」機能を導入しています。

たとえば、関数の値が整数型として返されると宣言しているとして、関数が文字列値またはnil値を返すときはどうなりますか。

その場合、コンパイラはエラー値を返します。これらの問題を取り除くために「オプション」が導入されました。

オプションの関数は2つの形式 ‘value’と ‘nil’のふた通りを表示します。’Optionalals’をキー予約文字 ‘？’で表示します。

その場合、タプルが値またはゼロ値を返すかどうかをチェックします。

func minMax(array: [Int]) -> (min: Int, max: Int)? {
   if array.isEmpty { return nil }
   var currentMin = array[0]
   var currentMax = array[0]
   
   for value in array[1..<array.count] {
      if value < currentMin {
         currentMin = value
      } else if value > currentMax {
         currentMax = value
      }
   }
   return (currentMin, currentMax)
}

if let bounds = minMax(array: [8, -6, 2, 109, 3, 71]) {
   print("min is \(bounds.min) and max is \(bounds.max)")
}

PLAYGROUNDで実行すると以下のようになります。

min is -6 and max is 109

”オプション ‘は、’ nil ‘やガーベジの値をチェックしてデバッグに多くの時間を費やし、コードを効率的かつ読めるようにします。

関数ローカルと外部パラメータ名

ローカルパラメータ名

ローカルパラメータ名は関数内でのみアクセスされます。

func sample(number: Int) {
   print(number)
}

ここでは、funcサンプルの引数番号は関数sample（）によって内部的にアクセスされるため、内部変数として宣言されています。

ここで、 ‘number’はローカル変数として宣言されていますが、変数への参照は関数の外部で次のステートメントで行われます。

func sample(number: Int) {
   print(number)
}

sample(number: 1)
sample(number: 2)
sample(number: 3)

PLAYGROUNDで実行すると以下のような結果が得られます。

1
2
3

外部パラメータ名

外部パラメータ名により、目的をより明確にするための関数パラメータの名前を付けることができます。たとえば、以下のように2つの関数のパラメータを指定し、その関数を呼び出すことができます。

func pow(firstArg a: Int, secondArg b: Int) -> Int {
   var res = a
   for _ in 1..<b {
      res = res * a
   }
   print(res)
   return res
}

pow(firstArg:5, secondArg:3)

PLAYGROUNで実行すると以下のようになります

可変パラメータ

複数の引数を持つ関数を定義する場合、メンバを ‘variadic’パラメータとして宣言できます。パラメータは、パラメータ名の後に（…）で可変的に指定できます。

func vari<N>(members: N...){
   for i in members {
      print(i)
   }
}

vari(members: 4,3,5)
vari(members: 4.5, 3.1, 5.6)
vari(members: "Swift 4", "Enumerations", "Closures")

PLAYGROUNDで実行すると下記のようになります

4
3
5
4.5
3.1
5.6
Swift 4
Enumerations
Closures

定数、変数、I / Oパラメータ

関数は、デフォルトではパラメータを「定数」とみなしますが、ユーザーは関数の引数を変数として宣言することもできます。

すでに ‘let’キーワードは定数パラメータを宣言するために使用され、可変パラメータは ‘var’キーワードで定義されることについて理解しました。

Swift 4のI / Oパラメータは、関数呼び出し後に値が変更されてもパラメータ値を保持する機能を提供します。関数パラメータ定義の初めに、 ‘inout’キーワードが宣言され、メンバ値が保持されます。

‘inout’というキーワードは、その値が関数に渡され、その値がその関数本体によってアクセスおよび変更され、元の引数を変更するために関数の ‘out’に戻されるためです。

変数は、その値だけが関数の内部と外部で変更されるため、in-outパラメーターの引数として渡されます。したがって、文字列とリテラルをイン・パラメータとして宣言する必要はありません。変数名の前の ‘＆’は、引数をin-outパラメーターに渡していることを示します。

func temp(a1: inout Int, b1: inout Int) {
   let t = a1
   a1 = b1
   b1 = t
}

var no = 2
var co = 10
temp(a1: &no, b1: &co)
print("Swapped values are \(no), \(co)")

私たちが上記のプログラムを遊び場で実行すると、次の結果が得られます。

Swapped values are 10, 2

関数型とその使用法

各関数は、入力パラメータを考慮して特定の関数に従い、目的の結果を出力します。

func inputs(no1: Int, no2: Int) -> Int {
   return no1/no2
}

以下はその例です –

func inputs(no1: Int, no2: Int) -> Int {
   return no1/no2
}

print(inputs(no1: 20, no2: 10))
print(inputs(no1: 36, no2: 6))

PLAYGROUNDで実行すると下記のようになります。

2
6

ここでは、関数は整数データ型として2つの引数no1とno2で初期化され、戻り値の型も ‘int’として宣言されます。

Func inputstr(name: String) -> String {
   return name
}

ここでは、関数は文字列データ型として宣言されています。

関数はvoid型のデータ型を持つこともあり、そのような関数は何も返しません。

func inputstr() {
   print("Swift 4 Functions")
   print("Types and its Usage")
}
inputstr()

私たちが上記のプログラムを遊び場で実行すると、次の結果が得られます。

Swift 4 Functions
Types and its Usage

上記の関数は引数と戻り値のないvoid関数として宣言されています。

関数型の使用

関数は、最初に整数、浮動小数点または文字列型の引数で渡され、その後、以下に述べるように関数に定数または変数として渡されます。

var addition: (Int, Int) -> Int = sum

ここでsumは、関数名の変数に ‘a’と ‘b’の整数変数を宣言した関数名です。

以降、加算関数と加算関数の両方が、整数データ型として宣言された引数の数と同じ数を持ち、参照として整数値を返します。

func sum(a: Int, b: Int) -> Int {
   return a + b
}
var addition: (Int, Int) -> Int = sum
print("Result: \(addition(40, 89))")

私たちが上記のプログラムを遊び場で実行すると、次の結果が得られます。

Result: 129

パラメータ型と戻り型としての関数型

また、関数自体をパラメータ型として別の関数に渡すこともできます。

func sum(a: Int, b: Int) -> Int {
   return a + b
}
var addition: (Int, Int) -> Int = sum
print("Result: \(addition(40, 89))")

func another(addition: (Int, Int) -> Int, a: Int, b: Int) {
   print("Result: \(addition(a, b))")
}
another(sum, 10, 20)

PLAYGROUNDで実行すると以下のようになります

Result: 129
Result: 30

入れ子関数

ネストされた関数は、内部関数を呼び出すことによって外部関数を呼び出す機能を提供します。

func calcDecrement(forDecrement total: Int) -> () -> Int {
   var overallDecrement = 0
   func decrementer() -> Int {
      overallDecrement -= total
      return overallDecrement
   }
   return decrementer
}

let decrem = calcDecrement(forDecrement: 30)
print(decrem())