Kotlin in action: 함수의 정의와 호출

코틀린에서 컬렉션 만들기

코틀린에서는 컬렉션을 다음과 같은 방법으로 만들 수 있다.

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")​

 

위의 객체가 어디에 속하는지 알아보면, class java.util.[클래스] 로 나온다.

 

이는 코틀린이 자신만의 컬렉션 기능을 제공하지 않는다는 것이다.

 

표준 자바 컬렉션을 활용하면 자바 코드와 상호작용하기가 훨씬 더 쉬워진다.

 

다음 코드는 자바와 똑같은 컬렉션 클래스를 사용하지만 코틀린에서 제공하는 추가적인 기능을 보여주고 있다.

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

println(strings.last()) // 리스트의 마지막 원소를 가져온다.

val numbers = setOf(1, 14, 2)

println(numbers.max()) // 컬렉션에서 최댓값을 가져온다.

 

함수를 호출하기 쉽게 만들기

자바 컬렉션에는 컬렉션에는 디폴트 toString 구현이 들어있다.

val list = listOf(1, 2, 3)
println(list)

// [1, 2, 3]

디폴트 구현과 달리 (1; 2; 3)처럼 원소 사이를 세미콜론으로 구분하고 괄호로 리스트를 둘러싸는 것을 구현해보자.

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()
}

//join to string 사용 방법
fun main(args: Array<String>) {
	val list = listOf(1, 2, 3)
	println(joinToString(list, "; ", "(", ")"))
	println(joinToString(collection = list, separator = ";", prefix = "(", postfix = ")"))
	println(joinToString(list))
	println(joinToString(list, "; "))
}

 

이 함수는 어떤 타입의 값을 원소로 하는 컬렉션이든 처리할 수 있다. 이런 함수를 우리는 제네릭 함수라고 한다.

디폴트 값과 자바

자바에는 디폴트 파라미터 값이라는 개념이 없어서 코틀린 함수를 자바에서 호출하는 경우에는 그 코틀린 함수가 디폴트 파라미터 값을 제공하더라도 모든 인자를 명시해야 한다.

자바에서 코틀린 함수를 자주 호출해야 한다면 자바 쪽에서 좀 더 편하게 코틀린 함수를 호출하고 싶을 것이다. 그럴 때 @JvmOverloads 애노테이션을 함수에 추가할 수 있다.

이 애노테이션은 함수에 추가하면 코틀린 컴파일러가 자동으로 맨 마지막 파라미터로 부터 파라미터를 하나씩 생략한 오버로딩한 자바 메소드를 추가해준다.

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

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

자바에서는 모든 코드를 클래스 기반에서 작성해야 한다. 하지만 특정 도메인 영역에는 포함되기 어려운 변수나 메소드를 생성해야 할 경우가 있는데, 클래스를 하나 생성하고 그 클래스에 static 멤버로 선언하여 사용하는 것이 보통이다.

 

코틀린에서는 코틀린파일의 최상위 수준, 모든 다른 클래스의 밖에 선언된 메소드와 프로퍼티는 static멤버로 처리한다.

 

한 패키지 안에서 파일에 함수를 선언해본다고 가정하자. 

코틀린도 JVM에서 실행되기 때문에, 코틀린 컴파일러는 이 파일을 컴파일할 때 코틀린 파일명으로 새로운 클래스를 정의해준다.

 

최상위 함수는 같은 Package에 들어있다면 따로 import된 값이 없이 마치 자신 파일에 함수 선언한 듯이 사용이 가능하다.

 

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

함수와 마찬가지로 최상위 프로퍼티도 정적 필드에 저장된다. 기본적으로 프로퍼티도 일반적인 프로퍼티처럼 접근자 ㅁ소드를 통해 자바코드에 노출된다.

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

기존 코드와 코틀린 코드를 자연스럽게 통합하는 것은 코틀린의 핵심 목표 중 하나다. 이런 기존 자바 API를 재작성하지 않고도 코틀린이 제공하는 여러 편리한 기능을 사용하는 방법이 바로 확장 함수이다.

 

개념적으로 확장 함수는 단순하다. 확장 함수는 어떤 클래스의 멤버 메소드인 것처럼 호출할 수 있지만 그 클래스의 밖에 선언된 함수다. 문자열의 마지막 문자를 돌려주는 확장 메소드를 추가해보자

package strings

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

 

확장 함수를 만들려면 추가하려는 함수 이름 앞에 그 함수가 확장할 클래스의 이름을 덧붙이기만 하면 된다. 클래스 이름을 수신 객체 타입(receiver type)이라 부르며, 확장 함수가 호출되는 대상이 되는 값(객체)을 수신 객체(receiver object)라고 부른다.

println("Kotlin".lastChar())
// String = 수신 객체 타입
// "Kotlin" = 수신 객체

 

확장 함수는 클래스 안에서 정의한 메소드와 달리 확장 함수 안에서는 클래스 내부에서만 사용할 수 있는 비공개(private) 멤버나 보호된(protected) 멤버를 사용할 수 없다.

임포트와 확장 함수

확장 함수를 사용하기 위해서는 그 함수를 다른 클래스나 함수와 마찬가지로 임포트해야만 한다. 확장 함수를 임포트 없이 사용한다면 동일한 이름의 확장 함수와 충돌할 수도 있기 때문에 임포트로 어떤 확장함수인지 명시해 주어야 한다.

import strings.lastChar // 명시적으로 사용

import strings.* // * 사용 가능

import strings.lastChar as last // as 키워드를 사용 가능

 

자바에서 확장 함수 호출

자바에서 확장 함수를 사용하기도 편하다. 단지 정적 메소드를 호출하면서 첫 번째 인자로 수신 객체를 넘기기만 하면 된다. 다른 최상위 함수와 마찬가지로 확장 함수가 들어있는 자바 클래스 이름도 확장 함수가 들어있는 파일 이름에 따라 결정된다. 따라서 확장 함수를 StringUtil.kt 파일에 정의했다면 다음과 같이 호출할 수 있다.

char c = StringUtilKt.lastChar("java");

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

이제 joinToString 함수의 최종 버전은 다음과 같다.

fun <T> Collection<T>.joinToString(
	separator: String = ", ",
	prefix: String = "",
	postfix: String = ""
): String {
		val result = StringBuilder(prefix)
		for ((index, element) in this.withIndex()) {
			if (index > 0) result.append(separator)
			result.append(element)
		}
	result.append(postfix)
	return result.toString()
}
fun main(args: Array<String>) {
	val list = arrayListOf(1, 2, 3)
	println(list.joinToString(" "))
}

 

확장 함수는 단지 정적 메소드 호출에 대한 문법적인 편의일 뿐이다.

그래서 클래스가 아닌 더 구체적인 타입을 수신 객체 타입으로 지정할 수도 있다.

확장 함수는 오버라이드할 수 없다.

확장 함수는 클래스의 일부가 아니다. 확장 함수는 클래스 밖에 선언된다.

 

이름과 파라미터가 완전히 같은 확장 함수를 기반 클래스와 하위 클래스에 대해 정의해도 실제로는 확장 함수를 호출할 때 수신 객체로 지정한 변수의 정적 타입에 의해 어떤 확장함수가 호출될지 결정되지, 그 변수에 저장된 객체의 동적인 타입에 의해 확장 함수가 결정되지 않는다.

확장 함수 팁

클래스를 확장한 함수와 그 클래스의 멤버 함수의 이름과 시그니처가 같다면 확장 함수가 아니라 멤버 함수가 호출된다.

 

확장 프로퍼티

확장 프로퍼티를 사용하면 기존 클래스 객체에 대한 프로퍼티 형식의 구문으로 사용할 수 있는 API를 추가할 수 있다.

 

프로퍼티라는 이름으로 불리기는 하지만 상태를 저장할 적절한 방법이 없기 때문에 실제로 확장 프로퍼티는 아무 상태도 가질 수 없다.

val String.lastChar: Char

get() = get(length -1)

 

뒷받침하는 필드가 없어서 기본 게터 구현을 제공할 수 없으므로 최소한 게터는 꼭 정의를 해야 한다.

 

마찬가지로 초기화 코드에서 계산한 값을 담을 장소가 전혀 없으므로 초기화 코드도 쓸 수 없다.

 

var StringBuilder.lastChar: Char
get() = get(length - 1)
set(value: Char) {
	this.setCharAt(length - 1, value)
}
fun main(args: Array<String>) {
	println("Kotlin".lastChar)
	val sb = StringBuilder("Kotlin?")
	sb.lastChar = '!'
	println(sb)
}

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

자바 컬렉션 API 확장

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

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

가변 길이 인자(varargs)는 메소드를 호출할 때 원하는 개수만큼 값을 인자로 넘기면 자바 컴파일러가 배열에 그 값들을 넣어주는 기능이다.

 

자바는 타입 뒤에 ...를 붙이는 대신 코틀린에서는 파라미터 앞에 vararg 변경자를 붙인다.

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

fun main(args: Array<String>) {
	val list = listOf("one", "two", "eight")
}

이미 배열에 들어있는 원소를 가변 길이 인자로 넘길 때 자바에서는 배열을 그냥 넘기면 되지만 코틀린에서는 배열을 명시적으로 풀어서 배열의 각 원소가 인자로 전달되게 해야 한다.

 

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

맵을 만들려면 mapOf 함수를 사용한다.

val map = mapOf(1 to "one", 7 to "seven", 53 to "fifty-three")

여기서 to라는 단어는 코틀린 키워드가 아니다.

 

이 코드는 중위 호출이라는 특별한 방식으로 to라는 일반 메소드를 호출한 것이다.

 

중위 호출 시에는 수신 객체와 유일한 메소드 인자 사이에 메소드 이름을 넣는다.

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

1 to "one" // "to" 메소드를 중위 호출 방식으로 호출함

 

함수(메소드)를 중위 호출에 사용하게 허용하고 싶으면 infix 변경자를 함수(메소드) 선언 앞에 추가해야 한다.

public infix fun <A, B> A.to(that: B): Pair<A, B> = Pair(this, that)

이런 기능을 구조 분해 선언이라고 부른다.

 

Pair 인스턴스 외 다른 객체에도 구조 분해를 적용할 수 있다. 예를 들어 key와 value라는 두 변수를 맵의 원소를 사용해 초기화할 수 있다.

for ((index, element) in collection.withIndex()) {
	println("$index: $element")
}

문자열과 정규식 다루기

코틀린은 다양한 확장 함수를 제공함으로써 표준 자바 문자열을 더 즐겁게 다루게 해준다.

 

또한 혼동이 야기될 수 있는 일부 메소드에 대해 더 명확한 코틀린 확장 함수를 제공함으로써 프로그래머의 실수를 줄여준다.

문자열 나누기

"12.345-6.A".split(".")라는 호출의 결과는 [12, 345-6,A] 의 배열이 아니다. 자바의 split 메소드는 빈 배열을 반환한다.

 

split의 구분 문자열은 실제로는 정규식이기 때문이다.

하지만 코틀린에서는 split 함수에 전달하는 값의 타입에 따라 정규식이나 일반 텍스트 중 어느 것으로 문자열을 분리하는지 쉽게 알 수 있다.

하지만 아까와 같이 간단한 경우에는 꼭 정규식을 쓸 필요가 없다. split 확장 함수를 오버로딩한 버전 중에는 구분 문자열을 하나 이상 인자로 받는 함수가 있다.

println("12.345-6.A".split(".","-")) // 여러 구분 문자열을 지정한다.

[12, 345, 6, A]​

정규식과 3중 따옴표로 묶은 문자열

다른 예로 두 가지 다른 구현을 만들어보자. 첫 번째 구현은 String을 확장한 함수를 사용하고 두 번째 구현은 정규식을 사용한다.

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 main(args: Array<String>) {
	parsePath("/Users/yole/kotlin-book/chapter.adoc")
}

 

path에서 처음부터 마지막 슬래시 직전까지의 부분 문자열은 파일이 들어있는 디렉터리경로다. path에서 마지막 마침표 다음부터 끝까지의 부분 문자열은 파일 확장자다.

코틀린에서는 정규식을 사용하지 않고도 문자열을 쉽게 파싱할 수 있다. 

fun parsePath(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")
	}
}

 

3중 따옴표 문자열에서는 역슬래시(\)를 포함한 어떤 문자도 이스케이프할 필요가 없다.

 

우선 정규식을 인자로 받은 path에 매치시킨다.

 

매치에 성공하면 그룹별로 분해한 매치 결과를 의미하는 destructured 프로퍼티를 각 변수에 대입한다.

 

이때 사용한 구조 분해 선언은 Pair로 두 변수를 초기화할 때 썼던 구문과 같다.

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

코틀린에서는 함수에서 추출한 함수를 원 함수 내부에 중첩시킬 수 있다. 그렇게 하면 문법적인 부가 비용을 들이지 않고도 깔끔하게 코드를 조직할 수 있다.

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.id}: empty Address")
	}
// Save user to the database
}

클래스가 자용자의 필드를 검증할 때 필요한 여러 경우를 하나씩 처리하는 메소드가 중복된 것을 개선해보자.

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")
// Save user to the database
}

 

검증 로직 중복은 사라졌고, 필요하면 User의 다른 필드에 대한 검증도 쉽게 추가할 수 있다.

 

User 객체를 로컬 함수에게 하나하나 전달해야 한다는 점을 로컬 함수가 자신이 속한 바깥 함수의 모든 파라미터와 변수를 사용해서 불필요한 User 파라미터를 없앨 수 있다.

fun saveUser(user: User) {
	fun validate(value: String, fieldName: String) { // user 파라미터를 중복 사용하지 않는다.
		if (value.isEmpty()) {
			throw IllegalArgumentException(
				"Can't save user ${user.id}: " + // 바깥 함수의 파라미터에 직접 접근할 수 있다.
				"empty $fieldName")
		}
	}
validate(user.name, "Name")
validate(user.address, "Address")
// Save user to the database
}

이 예제를 더 개선하고 싶다면 검증 로직을 User 클래스를 확장한 함수로 만들 수도 있다.

fun User.validateBeforeSave() {
	fun validate(value: String, 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()
// Save user to the database
}