9. 関数

概要

Kotlin の関数は、コードの再利用性を高め、プログラムをより簡潔にするために使用されます。

Kotlin では、関数は 第一級オブジェクト、ファーストクラスオブジェクト（First-class Object）として扱うことができます。
つまり、関数を他の変数に代入したり、 引数として渡したり、 戻り値として返すことができます。

標準ライブラリ関数、ビルトイン関数、およびユーザ定義関数について

標準ライブラリ関数、ビルトイン関数について

Kotlin は豊富な標準ライブラリ関数とビルトイン関数を備えており、 これらを利用することで様々な処理を簡潔に記述できます。

ビルトイン関数は、Kotlinの言語仕様に組み込まれている関数であり、どのプログラムでも即座に使用できる関数です。
これらの関数は、特定のタスクを簡単に実行するために設計されており、プログラムの基本的な機能を提供します。(println, readLine など)

fun main() {
    println("Hello, World!") // "Hello, World!"を出力
    val input = readLine() // ユーザーからの入力を読み取る
}

標準ライブラリ関数は、Kotlin の標準ライブラリに含まれる関数です。
コレクション操作 (filter, map など)、文字列処理 (substring, replace など)、数値計算 (maxOf, abs など) など、様々な機能を提供します。

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)
    val doubled = numbers.map { it * 2 } // 各要素を2倍にする
    println(doubled) // [2, 4, 6, 8, 10]を出力

    val evenNumbers = numbers.filter { it % 2 == 0 } // 偶数をフィルタリングする
    println(evenNumbers) // [2, 4]を出力

    val sortedNumbers = numbers.sorted() // ソートする
    println(sortedNumbers) // [1, 2, 3, 4, 5]を出力
}

標準ライブラリ関数、ビルトイン関数については別ページにもう少し記載します。

ユーザー定義関数

開発者は独自の関数を定義することができます。
これにより、特定の処理をカプセル化し再利用することができます。

Kotlin 関数は fun キーワードを使用して定義されます。

fun 関数名(パラメータの変数名: パラメータの型) : 関数が返す変数の型 {
    関数本体
    return 関数が返す値
} 

関数を定義したら、必要なときにいつでも何度でも呼び出すことができます。

関数名(引数)

例)

fun greet(name: String): String {
    return "Hello, $name!"
}

fun main() {
    println(greet("World")) // "Hello World!" を出力
}

パラメータと引数

関数はパラメータを受け取ることができます。

パラメータは関数に渡される値を一時的に保持するための変数のようなもので、 関数内で使用することができます。
パラメータは (パラメータ名: 型) の形式で定義します。

また、関数を呼び出す際に実際に渡す値のことを引数と呼びます。

つまり、パラメータは関数定義時に宣言される変数で、 引数は関数呼び出し時に渡される実際の値です。

fun add(a: Int, b: Int): Int {  // a, b はパラメータ
    return a + b
}

val result = add(3, 5)  // 3, 5 は引数, result には 8 が代入される

名前付き引数

名前付き引数を使用すると、関数の呼び出し時に引数の順番に依存せず、引数の名前を指定して値を渡すことができます。
これにより、引数の順序が不明な場合でもコードが読みやすくなります。

fun createPerson(name: String, age: Int, city: String): String {
    return "$name, $age years old, lives in $city."
}

fun main() {
    // 名前付き引数を使用して関数を呼び出す
    val personDescription = createPerson(age = 30, city = "New York", name = "Alice")
    println(personDescription) // Alice, 30 years old, lives in New York.
}

デフォルト引数

デフォルト引数を使用すると、関数のパラメータにデフォルト値を設定できます。
デフォルト値が設定されているパラメータに対しては、引数を省略することが可能で、省略するとデフォルト値が使われます。
これにより、関数の呼び出しが簡潔になります。

fun greet(name: String = "Guest", greeting: String = "Hello"): String {
    return "$greeting, $name!"
}

fun main() {
    println(greet()) // Hello, Guest! が出力される
    println(greet(name = "Alice")) // Hello, Alice! が出力される
    println(greet(greeting = "Hi", name = "Bob")) // Hi, Bob! が出力される
}

可変長引数

関数は可変長の引数を受け取ることができます。
可変長引数は vararg キーワードを使用して宣言します。可変長引数は関数内では配列として扱われます。

fun sum(vararg numbers: Int): Int {
    var total = 0
    for (number in numbers) {
        total += number
    }
    return total
}

val result1 = sum(1, 2, 3)  // result1 には 6 が代入される
val result2 = sum(4, 5, 6, 7)  // result2 には 22 が代入される

戻り値が無い関数 (Unit を返す関数)

関数は値を返さない場合もあります。その場合は戻り値の型を Unit と指定するか、戻り値の型の宣言を省略することができます。
Unit は Java の void に相当し、値を返さないことを表します。

fun printMessage(message: String): Unit {  // 戻り値の型を Unit と明記する。関数本体では 戻り値 に対して return Unit と記載する、return 文を省略する。
    println(message)
    return Unit // この return 文は省略可能
}

fun main() {
    printMessage("Hello, World!")
}

単一式関数、より短く定義する方法

関数の本体が単一の式 (expression) である場合、return キーワードを省略して式を直接返すことができます。
このような関数を単一式関数 (expression-body function) と呼びます。

fun double(x: Int) = x * 2

fun main() {
    println(double(4)) // 8 が出力される
}

ローカル関数

関数は他の関数の内部で定義することもできます。 このような関数をローカル関数と呼びます。ローカル関数は、定義された関数内でのみアクセス可能です。

fun outerFunction() {
    fun innerFunction() {
        println("This is from a local function")
    }
    innerFunction()
}

fun main() {
    outerFunction() // This is from a local function が出力される
}

関数の多重定義 (オーバーロード)

Kotlin では、関数名は完全に一致しているが、パラメータの型やパラメータの数が違う関数をつくることできます。
これを関数のオーバロード (多重定義) といいます。

fun printMessage(message: String) {
    println(message)
}

fun printMessage(number: Int) {
    println(number)
}

fun main() {
    printMessage("Hello")
    printMessage(123)
}

再帰呼び出し

関数が自分自身を呼び出すことを再帰呼び出しと言います。

例として、階乗(factorial) を求める関数の場合を記載します。
数式だと 自然数 n の階乗は、n! で表記しますが、1 から n までの全ての整数の席を示します。
n! = 1 * 2 * … * (n-1) * n
　= n * (n-1) * … * 2 * 1

for 文でこの処理を書くと以下のような形です。

fun main() {
    val num : Int = 5
    var result1 : Int = 1

    for (i in 1..num) {
        result1 = i * result1
    }
    println (result1)
}

同じ処理を fractrial という再帰呼び出しを行う関数を定義し、以下のように記述できます。 (5 x 4 x 3 x 2 x 1 = 120)

fun main() {
    val num = 5

    val result = factorial(num)
    println(result) // 5 * 4 * 3 * 2 * 1 の結果で 120 が出力される
}

fun fractrial (num : Int) : Int {
    val result : Int

    if (num <=1) {
        result = num
    } else {
        result = num * fractrial(num-1)  //再帰呼び出し
    }

    return result
}

オブジェクトとしての関数

Kotlin では、数値や文字などのオブジェクトと同様に、関数を一つのオブジェクトとして扱うことができます。
これにより、ある変数を用意して、それに関数を参照するオブジェクトを代入するといったことも可能です。

また、この関数をオブジェクトとして扱うという考え方ができることによって、無名関数やラムダ式の理解につなげることができます。
これらのの詳細は別ページに記載します。