3장 함수 정의와 호출

> [1,2,3] ``` - 디폴드 구현과 달리 (1;2;3) 처럼 원소"> > [1,2,3] ``` - 디폴드 구현과 달리 (1;2;3) 처럼 원소"> > [1,2,3] ``` - 디폴드 구현과 달리 (1;2;3) 처럼 원소">

# 3장 함수 정의와 호출

### 이번장에서는...

#### 배운점, 느낀점

1. 컬렉션, 문자열, 정규식을 다루기 위한 함수
2. 이름을 붙인 인자, 디폴트 파라미터 값, 중위 호출 문법 사용
3. 확장 함수와 확장 프로퍼티를 사용해 자바 라이브러리 적용
4. 최상위 및 로컬 함수와 프로퍼티를 사용해 코드 구조화

---

### 코틀린에서 컬렉션 만들기

```kotlin
package part3

val set = hashSetOf(1, 7, 53)
val list = arrayListOf(1, 7, 53)
val map = hashMapOf(1 to "one", 7 to "seven", 53 to "fifty-three") // to가 언어가 제공하는 특별한 키워드가 아니라 일반 함수라는 점에 유의

val strings = listOf("first", "second", "fourteenth")

fun main() {
    println(set.javaClass)
    println(list.javaClass)
    println(map.javaClass)

    println(strings.last())
    println(set.max())
}

코틀린이 자신만의 컬렉션 기능을 제공하지 않고, 기존 자바 컬렉션을 활용할 수 있다는 뜻이다.(상호작용을 위해)
코틀린 컬렉션은 자바 컬렉션과 똑같은 클래스다 하지만 코틀린에서는 자바보다 더 많은 기능을 쓸 수 있다. 예를 들어 리스트의 마지막 원소를 가져오거나 수로 이뤄진 컬렉션에서 최댓값을 찾을 수 있다.

함수를 호출하기 쉽게 만들

자바 컬렉션에는 디폴트 toString 구현이 들어있다. 하지만 그 디폴트 toString의 출력 형식은 고정돼 있고 우리에게 필요한 형식이 아닐 수 있다.

val list = listOf(1, 2, 3)
println(list)
// >> [1,2,3]

디폴드 구현과 달리 (1;2;3) 처럼 원소 사이를 세미콜론으로 구분하고 괄호로 리스트를 둘러싸고 싶다면 어떻게 해야 할까? 코틀린에는 이런 요구 사항을 처리할 수 있는 함수가 표준 라이브러리에 이미 들어있다.
직접 구현 해보았을 때

package part3

import java.lang.StringBuilder

fun <T> joinToString(  // 이 함수는 제네릭 하다 즉, 이 함수는 어떤 타입의 값을 원소로 하는 컬렉션이든 처리할 수 있다.
    collection: Collection<T>,
    separator: String,
    prefix: String,
    postfix: String
): String {
    val result = StringBuilder(prefix)

    for ((index, element) in collection.withIndex()) {
        if (index > 0) result.append(separator) // 첫 원소 앞에는 구분자를 붙이면 안 된다.
        result.append(element)
    }

    result.append(postfix)
    return result.toString()
}

fun main() {
    val list = listOf(1, 2, 3)
    println(joinToString(list, ";", "(", ")"))
}

이름을 붙인 인자

위의 예제의 함수 호출 부분의 가독성이 문제다. 아래 처럼 인자를 붙여 변경 가능

fun main() {
    val list = listOf(1, 2, 3)
    println(joinToString(collection = list, separator = ";", prefix = "(", postfix = ")"))
}

코틀린으로 작성한 함수를 호출할 때는 함수에 전달하는 인자 중 일부(또는 전부의) 이름을 명시할 수 있다. 호출 시 인자 중 어느 하나라도 이름을 명시하고 나면 혼동을 막기 위해 그 뒤에 오는 모든 인자는 이름을 꼭 명시해야한다.
불행히도 자바로 작성한 코드를 호출할 때는 이름 붙인 인자를 사용할 수 없다. 클래스 파일 (.class 파일)에 함수 파라미터 정보를 넣는 것은 자바 8 이후 추가된 선택적 특징인데, 코틀리는 jdk 6과 호환된다. 그 결과 코틀린 컴파일러는 함수 시그니처의 파라미터 이름을 인식할 수 없고, 여러분이 호출 시 사용한 인자 이름과 함수 정의의 파라미터 이름을 비교할 수 없다

디폴트 파라미터 값

자바에서는 일부 클래스에서 오버로딩한 메서드가 너무 많아진다는 문제가 있다.

fun <T> joinToString(  // 이 함수는 제네릭 하다 즉, 이 함수는 어떤 타입의 값을 원소로 하는 컬렉션이든 처리할 수 있다.
    collection: Collection<T>,
    separator: String = ",",
    prefix: String = "",
    postfix: String = ""
): String

코틀린에서는 함수 선언에서 파라미터의 디폴트 값을 지정할 수 있으므로 이런 오버로드 중 상당수를 피할 수 있다.
함수를 호출할 때 모든 인자를 쓸 수도 있고, 일부를 생략할 수 있다.
일반 호출 문법을 사용하려면 함수를 선언할 때와 같은 순서로 인자를 지정해야 한다. 그런 경우 일부를 생략하면 뒷부분의 인자들이 생략된다. 이름 붙인 인자를 사용하는 경우에는 인자 목록의 중간에 있는 인자를 생략하고, 지정하고 싶은 인자를 이름을 붙여서 순서와 관계없이 지정할 수 있다.
함수의 디폴트 파라미터 값은 함수를 호출하는 쪽이 아니라 함수 선언 쪽에서 지정된다
따라서 어떤 클래스 안에 정의된 함수의 디폴트 값을 바꾸고 그 클래스가 포함된 파일을 재 컴파일 하면 그 함수를 호출하는 코드 중에 값을 지정하지 않은 모든 인자는 자동으로 바뀐 디폴트 값을 적용받는다

디폴트 값과 자바

자바에는 디폴트 파라미터 값이라는 개념이 없어서 코틀린 함수를 자바에서 호출하는 경우에는 그 코틀린 함수가 디폴트 파라미터 값을 제공하더라도 모든 인자를 명시해야 한다.
자바 쪽에서 좀 더 편하게 코틀린 함수를 호출하고 싶으면 @JvmOverloads 애노테이션을 함수에 추가할 수 있다.

package part3;

import java.util.Collection;
import java.util.Iterator;
import java.util.List;

import kotlin.Metadata;
import kotlin.collections.CollectionsKt;
import kotlin.jvm.JvmOverloads;
import kotlin.jvm.internal.Intrinsics;
import org.jetbrains.annotations.NotNull;

@Metadata(
        mv = {1, 7, 1},
        k = 2,
        d1 = {"\\u0000\\u0018\\n\\u0000\\n\\u0002\\u0010\\u000e\\n\\u0002\\b\\u0002\\n\\u0002\\u0010\\u001e\\n\\u0002\\b\\u0004\\n\\u0002\\u0010\\u0002\\n\\u0000\\u001a:\\u0010\\u0000\\u001a\\u00020\\u0001\\"\\u0004\\b\\u0000\\u0010\\u00022\\f\\u0010\\u0003\\u001a\\b\\u0012\\u0004\\u0012\\u0002H\\u00020\\u00042\\b\\b\\u0002\\u0010\\u0005\\u001a\\u00020\\u00012\\b\\b\\u0002\\u0010\\u0006\\u001a\\u00020\\u00012\\b\\b\\u0002\\u0010\\u0007\\u001a\\u00020\\u0001H\\u0007\\u001a\\u0006\\u0010\\b\\u001a\\u00020\\t¨\\u0006\\n"},
        d2 = {"joinToString", "", "T", "collection", "", "separator", "prefix", "postfix", "main", "", "playground.main"}
)
public final class TwoKt {
    @JvmOverloads
    @NotNull
    public static final String joinToString(@NotNull Collection collection, @NotNull String separator, @NotNull String prefix, @NotNull String postfix) {
        Intrinsics.checkNotNullParameter(collection, "collection");
        Intrinsics.checkNotNullParameter(separator, "separator");
        Intrinsics.checkNotNullParameter(prefix, "prefix");
        Intrinsics.checkNotNullParameter(postfix, "postfix");
        StringBuilder result = new StringBuilder(prefix);
        int index = 0;

        for (Iterator var7 = ((Iterable) collection).iterator(); var7.hasNext(); ++index) {
            Object element = var7.next();
            if (index > 0) {
                result.append(separator);
            }

            result.append(element);
        }

        result.append(postfix);
        String var10000 = result.toString();
        Intrinsics.checkNotNullExpressionValue(var10000, "result.toString()");
        return var10000;
    }

    // $FF: synthetic method
    public static String joinToString$default(Collection var0, String var1, String var2, String var3, int var4, Object var5) {
        if ((var4 & 2) != 0) {
            var1 = ",";
        }

        if ((var4 & 4) != 0) {
            var2 = "";
        }

        if ((var4 & 8) != 0) {
            var3 = "";
        }

        return joinToString(var0, var1, var2, var3);
    }

    @JvmOverloads
    @NotNull
    public static final String joinToString(@NotNull Collection collection, @NotNull String separator, @NotNull String prefix) {
        return joinToString$default(collection, separator, prefix, (String) null, 8, (Object) null);
    }

    @JvmOverloads
    @NotNull
    public static final String joinToString(@NotNull Collection collection, @NotNull String separator) {
        return joinToString$default(collection, separator, (String) null, (String) null, 12, (Object) null);
    }

    @JvmOverloads
    @NotNull
    public static final String joinToString(@NotNull Collection collection) {
        return joinToString$default(collection, (String) null, (String) null, (String) null, 14, (Object) null);
    }

    public static final void main() {
        List list = CollectionsKt.listOf(new Integer[]{1, 2, 3});
        String var1 = joinToString((Collection) list, ";", "(", ")");
        System.out.println(var1);
        var1 = joinToString((Collection) list, ",", "", "");
        System.out.println(var1);
        var1 = joinToString$default((Collection) list, (String) null, (String) null, (String) null, 14, (Object) null);
        System.out.println(var1);
        var1 = joinToString$default((Collection) list, ";", (String) null, (String) null, 12, (Object) null);
        System.out.println(var1);
        Collection var10000 = (Collection) list;
        var1 = "#";
        String var2 = ";";
        var1 = joinToString$default(var10000, (String) null, var1, var2, 2, (Object) null);
        System.out.println(var1);
    }

    // $FF: synthetic method
    public static void main(String[] var0) {
        main();
    }
}

각각의 오버로딩한 함수들은 시그니처에서 생략된 파라미터에 대해 코틀린 함수의 디폴트 파라미터 값을 사용한다.

정적인 유틸리티 클래스 없애기: 최상위 함수와 프로퍼티

// 파일 이름 join
package part3.strings

import java.lang.StringBuilder

fun <T> joinToString(  // 이 함수는 제네릭 하다 즉, 이 함수는 어떤 타입의 값을 원소로 하는 컬렉션이든 처리할 수 있다.
    collection: Collection<T>,
    separator: String = ",",
    prefix: String = "",
    postfix: String = ""
): String {
    val result = StringBuilder(prefix)

    for ((index, element) in collection.withIndex()) {
        if (index > 0) result.append(separator) // 첫 원소 앞에는 구분자를 붙이면 안 된다.
        result.append(element)
    }

    result.append(postfix)
    return result.toString()
}

이를 자바로 변환하면

package part3.strings;

import java.util.Collection;
import java.util.Iterator;

import kotlin.Metadata;
import kotlin.jvm.internal.Intrinsics;
import org.jetbrains.annotations.NotNull;

@Metadata(
        mv = {1, 7, 1},
        k = 2,
        d1 = {"\\u0000\\u0012\\n\\u0000\\n\\u0002\\u0010\\u000e\\n\\u0002\\b\\u0002\\n\\u0002\\u0010\\u001e\\n\\u0002\\b\\u0004\\u001a8\\u0010\\u0000\\u001a\\u00020\\u0001\\"\\u0004\\b\\u0000\\u0010\\u00022\\f\\u0010\\u0003\\u001a\\b\\u0012\\u0004\\u0012\\u0002H\\u00020\\u00042\\b\\b\\u0002\\u0010\\u0005\\u001a\\u00020\\u00012\\b\\b\\u0002\\u0010\\u0006\\u001a\\u00020\\u00012\\b\\b\\u0002\\u0010\\u0007\\u001a\\u00020\\u0001¨\\u0006\\b"},
        d2 = {"joinToString", "", "T", "collection", "", "separator", "prefix", "postfix", "playground.main"}
)
public final class JoinKt {

}

클래스 이름이 JoinKt로 변환된다. join.kt 파일에 해당하는 클래스이다.
코틀린 컴파일러가 생성하는 클래스의 이름은 최상위 함수가 들어있던 코틀린 소스 파일의 이름과 대응한다.
코틀린 파일의 모든 최상위 함수는 이 클래스의 정적인 메서드가 된다. 따라서 자바에서 joinToString을 호풀하기는 쉽다.

package part3;

import part3.strings.JoinKt;

import java.util.Arrays;
import java.util.List;

public class CallJoin {

    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3);
        System.out.println(JoinKt.joinToString(list, ",", "", ""));
    }
}

@JvmName

코틀린 최상위 함수가 포함되는 클래스의 이름을 바꾸고 싶다면 파일에 @JvmName 애노테이션을 추가하면 된다.
@JvmName 애노테이션은 파일의 맨 앞, 패키지 이름 선언 이전에 위치해야 한다.

@file:JvmName("StringFunctions")

package part3.strings

import java.lang.StringBuilder

fun <T> joinToString(  // 이 함수는 제네릭 하다 즉, 이 함수는 어떤 타입의 값을 원소로 하는 컬렉션이든 처리할 수 있다.
    collection: Collection<T>,
    separator: String = ",",
    prefix: String = "",
    postfix: String = ""
): String

최상위 프로퍼티

함수와 마찬가지로 프로퍼티도 파일의 최상위 수준에 놓을 수 있다.

const val UNIX_LUNE_SEPARATOR = "\\n" // 최상위 프로퍼티

const 변경자를 추가하면 프로퍼티를 java에서 public static final 필드로 컴파일하게 만들 수 있다.(단, 원시 타입과 String 타입의 프로퍼티만 const로 지정할 수 있다.)

public static final String UNIX_LUNE_SEPARATOR="\\n";

메서드를 다른 클래스에 추가: 확장 함수와 확장 프로퍼티

기존 코드와 코틀린 코드를 자연스럽게 통합하는 것은 코틀린의 핵심 목표 중 하나다.
기존 자바 API를 재작성하지 않고도 코틀린이 제공하는 여러 편리한 기능을 사용할 수 있는 방법, 확장 함수가 그런 역할을 해줄 수 있다.
개념적으로 확장 함수는 단순하다. 확장 함수는 어떤 클래스의 멤버 메서드인 것처럼 호출할 수 있지만 그 클래스의 밖에 선언된 함수다.

package part3

fun String.lastChar(): Char = this.get(this.length - 1) // this -> 수신 객체
// String -> 수신 객체 타입

확장 함수를 만들려면 추가하려는 함수 이름 앞에 그 함수가 확장할 클래스의 이름을 덧붙이기만 하면 된다.
클래스 이름을 수신 객체 타입 이라 부르며, 확장 함수가 호출되는 대상이 되는 값(객체)을 수신 객체라고 부른다.
위의 함수를 호출하는 구문은 다른 일반 클래스 멤버를 호출하는 구문과 똑같다

println("Kotlin".lastChar())

그루비(Groovy)와 같은 다른 JVM 언어로 작성된 클래스도 확장할 수 있다. 자바 클래스로 컴파일한 클래스 파일이 있는 한 그 클래스에 원하는 대로 확장을 추가할 수 있다.

fun String.lastChar(): Char = get(length - 1) // 수신 객체 멤버에 this 없이 접근할 수 있다.

확장 함수 내부에서는 일반적인 인스턴스 메서드의 내부에서와 마찬가지로 수신 객체의 메서드나 프로퍼티를 바로 사용할 수 있다.
하지만 확장 함수가 캡슐화를 깨지는 않는다
클래스 안에서 정의한 메서드와 달리 확장 함수 안에서는 클래스 내부에서만 사용할 수 있는 비공개 멤버다 보호된 멤버를 사용할 수 없다.

임포트와 확장 함수

import strings.lastChar

import strings.*

import strings.lastChar as last

val c = "Kotlin".last()

코를린 문법상 확장 함수는 반드시 짧은 이름을 써야한다. 따라서 임포트할 때 이름을 바꾸는 것이 확장 함수 이름 충돌을 해결할 수 있는 유일한 방법이다.

자바에서 확장 함수 호출

내부적으로 확장 함수는 수신 객체를 첫 번째 인자로 받는 정적 메서드다. 그래서 확장 함수를 호출해도 다른 어댑터 객체나 실행 시점 부가 비용이 들지 않는다.

/* 자바 */
char c=StringUtilKt.lastChar("Java");

확장 함수 유틸리티 함수 정의

package part3.strings

fun <T> Collection<T>.joinToString(  // Collection<T>에 대한 확장 함수를 선언한다.
    separator: String = ",", // 파라미터의 디폴트 값을 지정한다.
    prefix: String = "",
    postfix: String = ""
): String {
    val result = StringBuilder(prefix)

    for ((index, element) in this.withIndex()) { //this 는 수신 객체를 가리킨다. 여기서는 T 타입의 원소로 이뤄진 컬렉션이다.
        if (index > 0) result.append(separator)
        result.append(element)
    }

    result.append(postfix)
    return result.toString()
}

fun Collection<String>.join(
    separator: String = ",",
    prefix: String = "",
    postfix: String = ""
) = joinToString(separator, prefix, postfix)

fun main() {
    val list = listOf(1, 2, 3)
    println(list.joinToString(separator = ";", prefix = "(", postfix = ")"))

    println(listOf("one", "two", "eight").join(" "))
}

확장 함수는 오버리아드 할 수 없다.

코틀린의 메서드 오버라이드도 일반적인 객체지향의 메서드 오버라이드와 마찬가지다.
하지만 확장 함수는 오버라이드할 수 없다.
확장 함수는 클래스의 일부가 아니다. 확장 함수는 클래스 밖에 선언된다. 이름과 파라미터가 완전히 같은 확장 함수를 기반 클래스와 하위 클래스에 대해 정의해도 실제로는 확장 함수를 호출할 때 수신 객체로 지정한 변수의 정적 타입에 의해 어떤 확장함수가 호출될지 결정되지, 그 변수에 저장된 객체의 동적인 타입에 의해 확장함수가 결정되지 않는다.

package part3

open class View {
    open fun click() = println("View clicked")
}

class Button : View() {
    override fun click() = println("Button clicked")
}

fun main() {
    val view: View = Button()
    view.click() // view에 저장된 값의 실제 타입에 따라 호출할 메서드가 결정된다.
}

// >> Button clicked

package part3

fun View.showOff() = println("I'm a view!")
fun Button.showOff() = println("I'm a button!")

fun main() {
    val view: View = Button()
    println(view.showOff())
}

// >>I'm a view!

view가 가리키는 객체의 실제 타입이 Button 이지만, 이경우 view의 타입이 View이기 때문에 무조건 View의 확장 함수가 호출된다.
확장 함수를 첫 번째 인자가 수신 객체인 정적 자바 메서드로 컴파일 한다. 자바도 호출할 정적 함수를 같은 방식으로 정적으로 결정한다.
코틀린은 호출될 확장 함수를 정적으로 결정하기 때문에 확장 함수를 오버라이드할 수는 없다.
어떤 클래스를 확장한 함수와 그 클래스의 멤버 함수의 이름과 시그니처가 같다면 확장 함수가 아니라 멤버 함수가 호출된다(멤버 함수의 우선순위가 더 높다)

확장 프로퍼티

확장 프로퍼티를 사용하면 기존 클래스 객체에 대한 프로퍼티 형식의 구문으로 사용할 수 있는 API를 추가할 수 있다. 프로퍼티라는 이름으로 불리기는 하지만 상태를 저장할 적절한 방법이 없기 때문에(기존 클래스의 인스턴스 객체에 필드를 추가할 방법은 없다) 실제로 확장 프로퍼티는 아무 상태도 가질 수 없다.

val String.lastChar: Char
    get() = get(length - 1)

var StringBuilder.last: Char
    get() = get(length - 1)
    set(value: Char) {
        this.setCharAt(length - 1, value)
    }

뒷받침하는 필드가 없어서 기본 게터 구현을 제공할 수 없으므로 최소한 게터는 꼭 정의를 해야한다.
StringBuilder에 같은 프로퍼티를 정의한다면 StringBuilder의 맨 마지막 문자는 변경 가능하므로 프로퍼티를 var로 만들 수 있다.

컬렉션 처리: 가변 길이 인자, 중위 함수 호출, 라이브러리 지원

vararg 키워드를 사용하면 호출 시 인자 개수가 달라질 수 있는 함수를 정의할 수 있다.
중위 함수 호출 구문을 사용하면 인자가 하나뿐인 메서드를 간편하게 호출할 수 있다.
구조 분해 선언을 사용하면 복합적인 값을 분해해서 여러 변수에 나눠 담을 수 있다.

자바 컬렉션 API 확장

코틀린 컬렉션은 자바와 같은 클래스를 사용하지만 더 확장된 API를 제공한다.

package part3

fun main() {
    val strings: List<String> = listOf("first", "second", "fourteenth")
    val numbers: Collection<Int> = setOf(1, 14, 2)

    println(strings.last())
    println(numbers.max())
}

last와 max는 모두 확장 함수 이다. last는 List 클래스의 확장 함수다.

가변 인자 함수: 인자의 개수가 달라질 수 있는 함수 정의

val list = listOf(2, 3, 5, 7, 11)

public fun <T> listOf(vararg elements: T): List<T> = if (elements.size > 0) elements.asList() else emptyList()

자바의 가변 길이 인자 varargs, 가변 길이 인자는 메서드를 호출할 떄 원하는 개수만큼 값을 인자로 넘기면 자바 컴파일러가 배열에 그 값들을 넣어주는 기능이다.
코틀린의 가변 길이 인자도 자바와 비슷하다. 다만 문법이 조금 다르다. 타입 뒤에 ...를 붙이는 대신 코틀린에서는 파라미터 앞에 vararg 변경자를 붙인다.
이미 배열에 들어있는 원소를 가변 길이 인자로 넘길 떄도 코틀린과 자바 구문이 다르다.
자바에서는 배열으 그냥 넘기면 되지만 코틀린에서는 배열을 명시적으로 풀어서 배열의 각 원소가 인자로 전달되게 해야 한다. 기술적으로는 스프레드 연산자가 그런 작업을 해준다. 하지만 실제로는 전달하려는 배열 앞에 *를 붙이기만 하면 된다.

fun main(args: Array<String>) {
    val list = listOf("args: ", *args) // 스프레드 연산자가 배열의 내용을 펼쳐준다
    println(list)
}

값의 쌍 다루기: 중위 호출과 구조 분해 선언

package part3

fun main(args: Array<String>) {
    val map = mapOf(1 to "one", 2 to "two", 3 to "three")
}

여기서 to라는 단어는 코틀린 키워드가 아니다. 이 코드는 중위 호풀이라는 특별한 방식으로 to라는 일반 메서드를 호출한 것이다.
중위 호풀 시에는 수신 객체와 유일한 메서드 인자 사이에 메서드 이름을 넣는다(이때 객체, 메서드 이름, 유일한 인자 사이에는 공백이 들어가야 한다)

1.to("one")  // to 메서드를 일반적인 방식으로 호출함
1 to "one"  // to 메서드를 중위 호풀 방식으로 호출함

val list = listOf(1, 2, 3)
mapOf(1 to "one", "one" to 1, list to list.size())

인자가 하나뿐인 일반 메서드나 인자가 하나뿐인 확장 함수에 중위 호출을 사용할 수 있다. 함수(메서드)를 중위 호출에 사용하게 허용하고 싶다면 infix변경자를 함수(메서드) 선언 앞에 추가해야한다.
to 함수는 확장 함수다 to를 사용하면 타입과 관계없이 임의의 순서쌍을 만들 수 있다. 이는 to의 수신 객체가 제네릭하다는 뜻이다.

package part3

infix fun Any.to(other: Any) = Pair(this, other)
// 이 to 함수는 Pair의 인스턴스를 반환한다.
// Pair는 코틀린 표준 라이브러리 클래스로, 그 이름대로 두 원소로 이뤄진 순서쌍을 표현한다
// 실제로 to는 제네릭 함수

fun main() {
    val (number, name) = 1 to "one"

    println("$number : $name")
}

이런 기능을 구조 분해 선언이라고 부른다.
mapOf의 경우 각 인자가 키와 값으로 이뤄진 순서쌍이어야 한다. 코틀린을 잘 모르는 사람이 보면 새로운 맵을 만드는 구문은 코틀린이 맵에 대해 제공하는 특별한 문법인 것처럼 느껴진다. 하지만 실제로는 일반적인 함수를 더 간결한 구문으로 호출하는 것 뿐이다.

package part3

fun main() {
    val collection = listOf(1, 2, 3, 4, 5)
    for ((index, element) in collection.withIndex()) {
        println("$index : $element")
    }
}

Pair 인스턴스 외 다른 객체에도 구조 분해를 적용할 수 있다. 예를 들어 key와 value라는 두 변수를 맵의 원소를 사용해 초기화할 수 있다.
루프에서도 구조 분해 선언을 활용할 수 있다 withIndex를 구조 분해 선언과 조합하면 컬렉션 원소의 인덱스와 값을 따로 변수에 담을 수 있다.

문자열과 정규식 다루기

코틀린 문자열은 자바 문자열과 같다.
코틀린 코드가 만들어낸 문자열을 아무 자바 메서드에 넘겨도 되며, 자바 코드에서 받은 문자열을 아무 코틀린 표준 라이브러리 함수에 전달해도 전혀 문제없다.
특별한 변환도 필요 없고 자바 문자열을 감싸는 별도의 래퍼도 생기지 않는다.
코틀린은 다양한 확장 함수를 제공함으로써 표준 자바 문자열을 더 즐겁게 다루게 해준다
또한 혼동이 야기될 수 있는 일부 메서드에 대해 더 명확한 코틀린 확장 함수를 제공함으로써 프로그래머의 실수를 줄여준다

문자열 나누기

package part3

fun main(args: Array<String>) {
    println("12.345-6.A".split("\\\\.|-".toRegex()))
    println("12.345-6.A".split(".", "-"))
}

문자열 대신 문자를 인자로 넘겨도 마찬가지 결과를 볼 수 있다. 이렇게 여러 문자를 받을 수 있는 코틀린 확장 함수는 자바에 있는 단 하나의 문자만 받을 수 있는 메서드를 대신한다.

정규식과 3중 따옴표로 묶은 문자열, 여러 줄 3중 따옴표 문자열

package part3

fun parsePath(path: String) {
    val directory = path.substringBeforeLast("/")
    val fullName = path.substringAfterLast("/")

    val fileName = fullName.substringBeforeLast(".")
    val extension = fullName.substringAfterLast(".")

    println("Dir: $directory, name: $fileName , ext: $extension")
}

fun parsePathByRegex(path: String) {
    val regex = """(.+)/(.+)\\.(.+)""".toRegex()
    val matchResult = regex.matchEntire(path)

    if (matchResult != null) {
        val (directory, fileName, extension) = matchResult.destructured
        println("Dir: $directory, name: $fileName , ext: $extension")
    }
}

fun main(args: Array<String>) {
    parsePath("/User/yole/kotlin-book/chapter.adoc")
    parsePathByRegex("/User/yole/kotlin-book/chapter.adoc")

    val kotlinLogo = """| //
                       .| //
                       .|/ \\ """

    println(kotlinLogo.trimMargin("."))
}

코틀린에서는 정규식을 사용하지 않고도 문자열을 쉽게 파싱할 수 있다. 정규식은 강력하기는 하지만 나중에 알아보기 힘든 경우도 많다. 정규식이 필요할 때는 코틀린 라이브러리를 사용하면 더 편하다
3중 따옴표 문자열을 문자열 이스케이프를 피하기 위해서만 사용하지 않는다. 3중 따옴표 문자열에는 줄바꿈을 표현하는 아무 문자열(이스케이프 없이) 그대로 들어간다.
3중 따옴표 문자열 안에서는 이스케이프를 할 수 없기 때문에 문자열 템플릿의 시작을 표현하는 $를 넣어야 한다면 문자열 안에 '$'를 넣어야 한다.

val price = """${'$'}99.9"""

코드 다듬기: 로컬 함수와 확장

코틀린에서는 함수에서 추출한 함수를 원 함수 내부에 중첩시킬 수 있다. 그렇게 하면 문법적이 부가 비용을 들이지 않고도 깔끔하게 코드를 조작할 수 있다.
흔히 발생하는 코드 중복을 로컬 함수를 통해 어떻게 제거할 수 있는지 살펴보자

코드 중복을 보여주는 예제

package part3

class User(
    val id: Int,
    val name: String,
    val address: String
)

fun saveUser(user: User) {
    if (user.name.isEmpty()) {
        throw IllegalArgumentException("Can't save user ${user.id}: empty Name")
    }

    if (user.address.isEmpty()) {
        throw IllegalArgumentException("Can't save user ${user.address}: empty Address")
    }
    // user를 데이터베이스에 저장한다.
}

fun main(args: Array<String>) {
    saveUser(User(1, "", ""))
}

로컬 함수를 사용해 코드 중복 줄이기

package part3

class User(
    val id: Int,
    val name: String,
    val address: String
)

fun saveUser(user: User) {

    fun validate(
        user: User,
        value: String,
        fieldName: String
    ) {
        if (value.isEmpty()) {
            throw IllegalArgumentException("Can't save user ${user.id}: empty $fieldName")
        }
    }

    validate(user, user.name, "Name")
    validate(user, user.address, "Address")
    // user를 데이터베이스에 저장한다.
}

fun main(args: Array<String>) {
    saveUser(User(1, "", ""))
}

로컬 함수에서 바깥 함수의 파라미터 접근하기

package part3

class User(
    val id: Int,
    val name: String,
    val address: String
)

fun saveUser(user: User) {

    fun validate(
        value: String, // 이제 saveUser 함수의 user 파라미터를 중복 사용하지않는다
        fieldName: String
    ) {
        if (value.isEmpty()) {
            throw IllegalArgumentException("Can't save user ${user.id}: empty $fieldName") // 바깥 함수의 파라미터에 접근할 수 있다.
        }
    }

    validate(user.name, "Name")
    validate(user.address, "Address")
    // user를 데이터베이스에 저장한다.
}

fun main(args: Array<String>) {
    saveUser(User(1, "", ""))
}

검증 로직을 확장 함수로 추출하기

package part3

class User(
    val id: Int,
    val name: String,
    val address: String
)

fun User.validateBeforeSave() {

    fun validate(
        value: String, // 이제 saveUser 함수의 user 파라미터를 중복 사용하지않는다
        fieldName: String
    ) {
        if (value.isEmpty()) {
            throw IllegalArgumentException("Can't save user ${id}: empty $fieldName") // 바깥 함수의 파라미터에 접근할 수 있다.
        }
    }

    validate(name, "Name")
    validate(address, "Address")
}

fun saveUser(user: User) {
    user.validateBeforeSave()
    // user를 데이터베이스에 저장한다.
}

fun main(args: Array<String>) {
    saveUser(User(1, "", ""))
}

확장 함수를 로컬 함수로 정의할 수도 있다. 즉 User.validateBeforeSave를 saveUser 내부에 로컬 함수로 넣을 수 있다. 하지만 중첩된 함수의 깊이가 깊어지면 코드를 읽기가 상당히 어려워진다. 따라서 일반적으로는 한 단계만 함수를 중첩시키라고 권장한다.

[출처] Kotlin IN ACTION