Skip to content

코딩 컨벤션 ​

널리 알려져 있고 따르기 쉬운 코딩 컨벤션은 어떤 프로그래밍 언어에서든 필수적입니다. 이 문서에서는 Kotlin을 사용하는 프로젝트를 위한 코드 스타일 및 코드 구성 가이드라인을 제공합니다.

IDE에서 스타일 설정하기 ​

Kotlin에서 가장 많이 사용되는 두 가지 IDE인 IntelliJ IDEA와 Android Studio는 코드 스타일에 대한 강력한 지원을 제공합니다. 지정된 코드 스타일에 맞추어 코드를 자동으로 포맷팅하도록 IDE를 설정할 수 있습니다.

스타일 가이드 적용하기 ​

  1. Settings/Preferences | Editor | Code Style | Kotlin으로 이동합니다.
  2. Set from...을 클릭합니다.
  3. Kotlin style guide를 선택합니다.

코드가 스타일 가이드를 따르는지 확인하기 ​

  1. Settings/Preferences | Editor | Inspections | General로 이동합니다.
  2. Incorrect formatting 검사(Inspection)를 활성화합니다. 스타일 가이드에 설명된 다른 문제들(예: 네이밍 컨벤션)을 검증하는 추가 검사는 기본적으로 활성화되어 있습니다.

자세한 내용은 IntelliJ IDEA로 Kotlin 코드 스타일로 마이그레이션하기 가이드를 참고하세요.

소스 코드 구성 ​

디렉터리 구조 ​

순수 Kotlin 프로젝트에서 권장되는 디렉터리 구조는 공통 루트 패키지를 생략한 패키지 구조를 따릅니다. 예를 들어, 프로젝트의 모든 코드가 org.example.kotlin 패키지 및 그 하위 패키지에 있는 경우, org.example.kotlin 패키지의 파일은 소스 루트 바로 아래에 위치해야 하며, org.example.kotlin.network.socket의 파일은 소스 루트의 network/socket 하위 디렉터리에 위치해야 합니다.

JVM의 경우: Kotlin을 Java와 함께 사용하는 프로젝트에서는 Kotlin 소스 파일이 Java 소스 파일과 동일한 소스 루트에 있어야 하며, 동일한 디렉터리 구조를 따라야 합니다. 즉, 각 파일은 각 패키지 선언에 해당하는 디렉터리에 저장되어야 합니다.

소스 파일 이름 ​

Kotlin 파일에 단일 클래스 또는 인터페이스(관련된 최상위 선언 포함 가능)만 포함되어 있는 경우, 파일 이름은 클래스 이름 뒤에 .kt 확장자를 붙인 것과 같아야 합니다. 이는 모든 유형의 클래스와 인터페이스에 적용됩니다. 파일에 여러 클래스가 포함되어 있거나 최상위 선언만 있는 경우, 파일의 내용을 설명하는 이름을 선택하여 파일 이름을 지정하세요. 각 단어의 첫 글자를 대문자로 표기하는 어퍼 카멜 케이스(Upper camel case)를 사용합니다. 예: ProcessDeclarations.kt.

파일 이름은 해당 파일의 코드가 수행하는 작업을 설명해야 합니다. 따라서 파일 이름에 Util과 같이 무의미한 단어를 사용하는 것은 피해야 합니다.

멀티플랫폼 프로젝트 ​

멀티플랫폼 프로젝트에서 플랫폼별 소스 세트에 최상위 선언이 포함된 파일은 소스 세트의 이름과 연관된 접미사를 가져야 합니다. 예:

  • jvmMain/kotlin/Platform.jvm.kt
  • androidMain/kotlin/Platform.android.kt
  • iosMain/kotlin/Platform.ios.kt

공통(Common) 소스 세트의 경우 최상위 선언이 있는 파일에 접미사를 붙이지 않아야 합니다. 예: commonMain/kotlin/Platform.kt.

기술 세부 사항 ​

멀티플랫폼 프로젝트에서 이러한 파일 네이밍 방식을 따르도록 권장하는 이유는 JVM 제한 때문입니다. JVM은 최상위 멤버(함수, 프로퍼티)를 허용하지 않습니다.

이를 해결하기 위해 Kotlin JVM 컴파일러는 최상위 멤버 선언을 포함하는 래퍼 클래스(소위 "파일 파사드(file facade)")를 생성합니다. 파일 파사드는 파일 이름에서 파생된 내부 이름을 가집니다.

한편, JVM은 동일한 완전 정규화된 이름(FQN, Fully Qualified Name)을 가진 여러 클래스를 허용하지 않습니다. 이로 인해 Kotlin 프로젝트를 JVM으로 컴파일할 수 없는 상황이 발생할 수 있습니다.

none
root
|- commonMain/kotlin/myPackage/Platform.kt // 'fun count() { }' 포함
|- jvmMain/kotlin/myPackage/Platform.kt // 'fun multiply() { }' 포함

여기서 두 Platform.kt 파일이 동일한 패키지에 있으므로, Kotlin JVM 컴파일러는 두 개의 파일 파사드를 생성하며, 둘 다 myPackage.PlatformKt라는 FQN을 갖게 됩니다. 이로 인해 "Duplicate JVM classes" 오류가 발생합니다.

이를 방지하는 가장 간단한 방법은 위의 가이드라인에 따라 파일 중 하나의 이름을 바꾸는 것입니다. 이 네이밍 규칙은 코드 가독성을 유지하면서 충돌을 방지하는 데 도움이 됩니다.

이러한 권장 사항이 불필요해 보일 수 있는 두 가지 시나리오가 있지만, 여전히 따르는 것을 권장합니다.

  • 비 JVM 플랫폼에는 중복 파일 파사드 문제가 없습니다. 그러나 이 네이밍 규칙은 파일 이름의 일관성을 유지하는 데 도움이 됩니다.

  • JVM에서 소스 파일에 최상위 선언이 없는 경우 파일 파사드가 생성되지 않으므로 이름 충돌이 발생하지 않습니다.

    그러나 이 네이밍 규칙을 따르면 간단한 리팩터링이나 기능 추가로 최상위 함수가 포함되어 동일한 "Duplicate JVM classes" 오류가 발생하는 상황을 방지할 수 있습니다.

소스 파일 구성 ​

선언(클래스, 최상위 함수 또는 프로퍼티)들이 의미상 서로 밀접하게 연관되어 있고 파일 크기가 적절한 수준(수백 줄을 초과하지 않음)을 유지하는 한, 동일한 Kotlin 소스 파일에 여러 선언을 배치하는 것이 권장됩니다.

특히, 특정 클래스의 모든 클라이언트와 관련된 확장 함수를 정의할 때는 해당 클래스 자체와 같은 파일에 배치하세요. 특정 클라이언트에만 의미가 있는 확장 함수를 정의할 때는 해당 클라이언트의 코드 옆에 배치하세요. 단지 어떤 클래스의 모든 확장을 모아두기 위한 파일을 만드는 것은 피하세요.

클래스 레이아웃 ​

클래스의 내용은 다음 순서로 배치되어야 합니다.

  1. 프로퍼티 선언 및 초기화 블록
  2. 보조 생성자
  3. 메서드 선언
  4. 동반 객체(Companion object)

메서드 선언을 알파벳순이나 가시성별로 정렬하지 말고, 일반 메서드를 확장 메서드와 분리하지 마세요. 대신 관련된 요소들을 함께 배치하여 클래스를 위에서 아래로 읽는 사람이 무슨 일이 일어나고 있는지 로직을 따라갈 수 있도록 하세요. 순서(상위 수준 내용을 먼저 배치하거나 그 반대로 배치)를 정하고 이를 일관되게 유지하세요.

중첩 클래스는 해당 클래스를 사용하는 코드 옆에 배치하세요. 클래스가 외부에서 사용되도록 의도되었고 클래스 내부에서 참조되지 않는 경우, 동반 객체 뒤의 맨 마지막에 배치하세요.

인터페이스 구현 레이아웃 ​

인터페이스를 구현할 때는 구현 멤버를 인터페이스 멤버와 동일한 순서로 유지하세요(필요한 경우 구현에 사용되는 추가 private 메서드를 사이에 둘 수 있습니다).

오버로드 레이아웃 ​

클래스 내에서 오버로드는 항상 서로 인접하게 배치하세요.

네이밍 규칙 ​

Kotlin의 패키지 및 클래스 네이밍 규칙은 매우 간단합니다.

  • 패키지 이름은 항상 소문자이며 밑줄을 사용하지 않습니다(org.example.project). 여러 단어로 된 이름을 사용하는 것은 일반적으로 권장되지 않지만, 여러 단어를 사용해야 하는 경우 단순히 연결하거나 카멜 케이스를 사용할 수 있습니다(org.example.myProject).

  • 클래스와 객체의 이름은 어퍼 카멜 케이스를 사용합니다.

kotlin
open class DeclarationProcessor { /*...*/ }

object EmptyDeclarationProcessor : DeclarationProcessor() { /*...*/ }

함수 이름 ​

함수, 프로퍼티, 로컬 변수의 이름은 소문자로 시작하며 밑줄 없이 카멜 케이스를 사용합니다.

kotlin
fun processDeclarations() { /*...*/ }
var declarationCount = 1

클래스 형태의 함수 이름 ​

함수 이름이 클래스 네이밍 규칙을 따라야 하는 두 가지 예외가 있습니다. 이러한 종류의 함수는 대개 최상위 수준에서 정의됩니다.

  • 클래스 인스턴스를 생성하는 팩토리 함수는 추상 반환 타입과 동일한 이름을 가질 수 있습니다.

    kotlin
    interface Foo { /*...*/ }
    
    class FooImpl : Foo { /*...*/ }
    
    fun Foo(): Foo { return FooImpl() }
  • Unit을 반환하는 @Composable 함수:

    kotlin
    @Composable fun TabHeader { /*...*/ }

테스트 메서드 이름 ​

테스트(및 테스트에서만)에서는 백틱으로 묶인 공백이 포함된 메서드 이름을 사용할 수 있습니다. 이러한 메서드 이름은 API 레벨 30 이상의 Android 런타임에서만 지원됩니다. 테스트 코드에서는 메서드 이름에 밑줄을 사용하는 것도 허용됩니다.

kotlin
class MyTestCase {
    @Test fun `ensure everything works`() { /*...*/ }

    @Test fun ensureEverythingWorks_onAndroid() { /*...*/ }
}

프로퍼티 이름 ​

상수(const로 표시된 프로퍼티, 또는 깊은 불변(deeply immutable) 데이터를 보유하며 커스텀 get 함수가 없는 최상위 또는 객체 val 프로퍼티)의 이름은 스크리밍 스네이크 케이스(Screaming snake case) 규칙에 따라 모두 대문자를 사용하고 밑줄로 구분해야 합니다.

kotlin
const val MAX_COUNT = 8
val USER_NAME_FIELD = "UserName"

동작을 가진 객체나 변경 가능한 데이터를 담고 있는 최상위 또는 객체 프로퍼티의 이름은 카멜 케이스를 사용해야 합니다.

kotlin
val mutableCollection: MutableSet<String> = HashSet()

싱글톤 객체에 대한 참조를 갖는 프로퍼티의 이름은 object 선언과 동일한 네이밍 스타일을 사용할 수 있습니다.

kotlin
val PersonComparator: Comparator<Person> = /*...*/

enum 상수의 경우, 용도에 따라 모두 대문자로 밑줄 구분된 이름(스크리밍 스네이크 케이스)(enum class Color { RED, GREEN })을 사용하거나 어퍼 카멜 케이스 이름을 사용할 수 있습니다.

백킹 프로퍼티 이름 ​

클래스에 개념상 동일하지만 하나는 공개 API의 일부이고 다른 하나는 구현 세부 정보인 두 개의 프로퍼티가 있는 경우, private 프로퍼티의 이름 접두사로 밑줄을 사용하세요.

kotlin
class C {
    private val _elementList = mutableListOf<Element>()

    val elementList: List<Element>
        get() = _elementList
}

좋은 이름 선택하기 ​

클래스의 이름은 대개 클래스가 무엇_인지_를 설명하는 명사 또는 명사구입니다: List, PersonReader.

메서드의 이름은 대개 메서드가 무엇을 하는지 나타내는 동사 또는 동사구입니다: close, readPersons. 이름은 메서드가 객체를 변경(mutate)하는지, 아니면 새로운 객체를 반환하는지도 암시해야 합니다. 예를 들어 sort는 컬렉션을 제자리에서(in place) 정렬하지만, sorted는 컬렉션의 정렬된 복사본을 반환합니다.

이름은 엔티티의 목적을 명확히 전달해야 하므로, 이름에 무의미한 단어(Manager, Wrapper)를 사용하는 것은 피하는 것이 좋습니다.

선언 이름의 일부로 두문자어(Acronym)를 사용할 때는 다음 규칙을 따르세요.

  • 두 글자로 된 두문자어는 두 글자 모두 대문자를 사용합니다. 예: IOStream.
  • 두 글자를 초과하는 두문자어는 첫 글자만 대문자로 표기합니다. 예: XmlFormatter 또는 HttpInputStream.

포맷팅 ​

들여쓰기 ​

들여쓰기에는 공백 4개를 사용하세요. 탭은 사용하지 마세요.

중괄호의 경우, 여는 중괄호는 구문이 시작되는 줄의 끝에 두고, 닫는 중괄호는 여는 구문과 수평으로 정렬하여 별도의 줄에 배치합니다.

kotlin
if (elements != null) {
    for (element in elements) {
        // ...
    }
}

Kotlin에서는 세미콜론이 선택 사항이므로 줄바꿈이 의미를 갖습니다. 언어 설계상 Java 스타일의 중괄호를 가정하므로, 다른 포맷팅 스타일을 사용하려고 하면 예기치 않은 동작이 발생할 수 있습니다.

수평 공백 ​

  • 이항 연산자(a + b) 주위에 공백을 둡니다. 예외: "범위 지정(range to)" 연산자(0..i) 주위에는 공백을 두지 않습니다.
  • 단항 연산자(a++) 주위에는 공백을 두지 않습니다.
  • 제어 흐름 키워드(if, when, for, while)와 해당하는 여는 괄호 사이에 공백을 둡니다.
  • 기본 생성자 선언, 메서드 선언 또는 메서드 호출 시 여는 괄호 앞에 공백을 두지 않습니다.
kotlin
class A(val x: Int)

fun foo(x: Int) { ... }

fun bar() {
    foo(1)
}
  • (, [ 뒤나 ], ) 앞에는 절대 공백을 두지 않습니다.
  • . 또는 ?. 주위에는 절대 공백을 두지 않습니다: foo.bar().filter { it > 2 }.joinToString(), foo?.bar().
  • // 뒤에는 공백을 둡니다: // This is a comment.
  • 타입 매개변수를 지정하는 데 사용되는 꺾쇠괄호 주위에는 공백을 두지 않습니다: class Map<K, V> { ... }.
  • :: 주위에는 공백을 두지 않습니다: Foo::class, String::length.
  • 널 허용(Nullable) 타입을 표시하는 데 사용되는 ? 앞에는 공백을 두지 않습니다: String?.

일반적인 규칙으로, 어떤 종류의 수평 정렬도 피하세요. 식별자 이름을 다른 길이의 이름으로 변경할 때 선언이나 사용처의 포맷팅에 영향을 주지 않아야 합니다.

콜론 ​

다음과 같은 시나리오에서는 : 앞에 공백을 둡니다.

  • 타입과 상위 타입을 구분하는 데 사용될 때.
  • 상위 클래스 생성자 또는 동일 클래스의 다른 생성자로 위임할 때.
  • object 키워드 뒤.

선언과 그 타입을 구분할 때는 : 앞에 공백을 두지 않습니다.

: 뒤에는 항상 공백을 둡니다.

kotlin
abstract class Foo<out T : Any> : IFoo {
    abstract fun foo(a: Int): T
}

class FooImpl : Foo() {
    constructor(x: String) : this(x) { /*...*/ }

    val x = object : IFoo { /*...*/ } 
}

클래스 헤더 ​

기본 생성자 매개변수가 적은 클래스는 한 줄로 작성할 수 있습니다.

kotlin
class Person(id: Int, name: String)

헤더가 긴 클래스는 각 기본 생성자 매개변수가 들여쓰기된 별도의 줄에 위치하도록 포맷팅해야 합니다. 또한 닫는 괄호는 새 줄에 있어야 합니다. 상속을 사용하는 경우, 상위 클래스 생성자 호출이나 구현된 인터페이스 목록은 괄호와 같은 줄에 위치해야 합니다.

kotlin
class Person(
    id: Int,
    name: String,
    surname: String
) : Human(id, name) { /*...*/ }

인터페이스가 여러 개인 경우, 상위 클래스 생성자 호출을 먼저 배치한 다음 각 인터페이스를 다른 줄에 배치해야 합니다.

kotlin
class Person(
    id: Int,
    name: String,
    surname: String
) : Human(id, name),
    KotlinMaker { /*...*/ }

상위 타입 목록이 긴 클래스의 경우, 콜론 뒤에 줄바꿈을 넣고 모든 상위 타입 이름을 수평으로 정렬합니다.

kotlin
class MyFavouriteVeryLongClassHolder :
    MyLongHolder<MyFavouriteVeryLongClass>(),
    SomeOtherInterface,
    AndAnotherOne {

    fun foo() { /*...*/ }
}

클래스 헤더가 길 때 클래스 헤더와 본문을 명확히 구분하려면, 위의 예시처럼 클래스 헤더 뒤에 빈 줄을 넣거나, 여는 중괄호를 별도의 줄에 배치하세요.

kotlin
class MyFavouriteVeryLongClassHolder :
    MyLongHolder<MyFavouriteVeryLongClass>(),
    SomeOtherInterface,
    AndAnotherOne 
{
    fun foo() { /*...*/ }
}

생성자 매개변수에는 일반 들여쓰기(공백 4개)를 사용하세요. 이렇게 하면 기본 생성자에서 선언된 프로퍼티가 클래스 본문에서 선언된 프로퍼티와 동일한 들여쓰기를 갖게 됩니다.

제어자 순서 ​

선언에 여러 제어자(Modifier)가 있는 경우, 항상 다음 순서로 배치하세요.

kotlin
public / protected / private / internal
expect / actual
final / open / abstract / sealed / const
external
override
lateinit
tailrec
vararg
suspend
inner
enum / annotation / fun // `fun interface`의 제어자로 사용될 때
companion
inline / value
infix
operator
data

모든 어노테이션은 제어자 앞에 배치합니다.

kotlin
@Named("Foo")
private val foo: Foo

라이브러리를 작업하는 경우가 아니라면, 중복되는 제어자(예: public)는 생략하세요.

어노테이션 ​

어노테이션은 적용 대상 선언 앞의 별도 줄에 동일한 들여쓰기로 배치합니다.

kotlin
@Target(AnnotationTarget.PROPERTY)
annotation class JsonExclude

인자가 없는 어노테이션은 같은 줄에 배치할 수 있습니다.

kotlin
@JsonExclude @JvmField
var x: String

인자가 없는 단일 어노테이션은 해당 선언과 같은 줄에 배치할 수 있습니다.

kotlin
@Test fun foo() { /*...*/ }

파일 어노테이션 ​

파일 어노테이션은 파일 주석(있는 경우) 뒤, package 문 앞에 배치하며, package와는 빈 줄로 구분합니다(패키지가 아닌 파일 자체를 대상으로 한다는 점을 강조하기 위함).

kotlin
/** License, copyright and whatever */
@file:JvmName("FooBar")

package foo.bar

함수 ​

함수 시그니처가 한 줄에 들어가지 않는 경우 다음 구문을 사용하세요.

kotlin
fun longMethodName(
    argument: ArgumentType = defaultValue,
    argument2: AnotherArgumentType,
): ReturnType {
    // body
}

함수 매개변수에는 일반 들여쓰기(공백 4개)를 사용하세요. 이는 생성자 매개변수와의 일관성을 유지하는 데 도움이 됩니다.

본문이 단일 표현식으로 구성된 함수의 경우 표현식 본문(Expression body)을 사용하는 것이 좋습니다.

kotlin
fun foo(): Int {     // 나쁨
    return 1 
}

fun foo() = 1        // 좋음

표현식 본문 ​

함수에 첫 번째 줄이 선언과 같은 줄에 맞지 않는 표현식 본문이 있는 경우, 첫 번째 줄에 = 기호를 넣고 표현식 본문을 공백 4개로 들여씁니다.

kotlin
fun f(x: String, y: String, z: String) =
    veryLongFunctionCallWithManyWords(andLongParametersToo(), x, y, z)

프로퍼티 ​

매우 단순한 읽기 전용 프로퍼티의 경우 한 줄 포맷팅을 고려하세요.

kotlin
val isEmpty: Boolean get() = size == 0

더 복잡한 프로퍼티의 경우, get과 set 키워드를 항상 별도의 줄에 배치하세요.

kotlin
val foo: String
    get() { /*...*/ }

초기화 식이 있는 프로퍼티의 경우, 초기화 식이 길다면 = 기호 뒤에 줄바꿈을 추가하고 초기화 식을 공백 4개로 들여씁니다.

kotlin
private val defaultCharset: Charset? =
    EncodingRegistry.getInstance().getDefaultCharsetForPropertiesFiles(file)

제어 흐름문 ​

if 또는 when 문의 조건이 여러 줄인 경우, 항상 문장의 본문 주위에 중괄호를 사용하세요. 조건문의 후속 각 줄은 문장 시작을 기준으로 공백 4개만큼 들여씁니다. 조건의 닫는 괄호는 여는 중괄호와 함께 별도의 줄에 배치합니다.

kotlin
if (!component.isSyncing &&
    !hasAnyKotlinRuntimeInScope(module)
) {
    return createKotlinNotConfiguredPanel(module)
}

이렇게 하면 조건과 문장 본문을 정렬하는 데 도움이 됩니다.

else, catch, finally 키워드 및 do-while 루프의 while 키워드는 이전 중괄호와 같은 줄에 배치합니다.

kotlin
if (condition) {
    // body
} else {
    // else part
}

try {
    // body
} finally {
    // cleanup
}

when 문에서 한 분기(branch)가 두 줄 이상인 경우, 인접한 case 블록과 빈 줄로 구분하는 것을 고려하세요.

kotlin
private fun parsePropertyValue(propName: String, token: Token) {
    when (token) {
        is Token.ValueToken ->
            callback.visitValue(propName, token.value)

        Token.LBRACE -> { // ...
        }
    }
}

짧은 분기는 중괄호 없이 조건과 같은 줄에 배치합니다.

kotlin
when (foo) {
    true -> bar() // 좋음
    false -> { baz() } // 나쁨
}

메서드 호출 ​

긴 인자 목록에서는 여는 괄호 뒤에 줄바꿈을 넣습니다. 인자는 공백 4개로 들여씁니다. 밀접하게 관련된 여러 인자는 같은 줄에 그룹화합니다.

kotlin
drawSquare(
    x = 10, y = 10,
    width = 100, height = 100,
    fill = true
)

인자 이름과 값을 구분하는 = 기호 주위에는 공백을 둡니다.

체인 호출 줄바꿈 ​

체인 호출(Chained call)을 줄바꿈할 때는 단일 들여쓰기를 적용하여 . 문자 또는 ?. 연산자를 다음 줄에 배치합니다.

kotlin
val anchor = owner
    ?.firstChild!!
    .siblings(forward = true)
    .dropWhile { it is PsiComment || it is PsiWhiteSpace }

체인의 첫 번째 호출 앞에는 대개 줄바꿈을 넣어야 하지만, 코드가 그 편이 더 자연스럽다면 생략해도 무방합니다.

람다 ​

람다 표현식에서는 중괄호 주위와 매개변수를 본문과 구분하는 화살표 주위에 공백을 사용해야 합니다. 호출이 단일 람다를 받는 경우 가능한 한 괄호 밖으로 전달하세요.

kotlin
list.filter { it > 10 }

람다에 레이블을 할당하는 경우, 레이블과 여는 중괄호 사이에 공백을 두지 마세요.

kotlin
fun foo() {
    ints.forEach lit@{
        // ...
    }
}

여러 줄 람다에서 매개변수 이름을 선언할 때는 첫 번째 줄에 이름을 두고, 그 뒤에 화살표와 줄바꿈을 배치합니다.

kotlin
appendCommaSeparated(properties) { prop ->
    val propertyValue = prop.get(obj)  // ...
}

매개변수 목록이 너무 길어 한 줄에 맞지 않는 경우 화살표를 별도의 줄에 배치합니다.

kotlin
foo {
    context: Context,
    environment: Env
    ->
    context.configureEnv(environment)
}

후행 쉼표 ​

후행 쉼표(Trailing comma)는 일련의 요소 중 마지막 항목 뒤에 오는 쉼표 기호입니다.

kotlin
class Person(
    val firstName: String,
    val lastName: String,
    val age: Int, // 후행 쉼표
)

후행 쉼표를 사용하면 몇 가지 장점이 있습니다.

  • 버전 관리 시스템의 diff가 더 깔끔해집니다. 변경된 값에만 집중할 수 있습니다.
  • 요소를 추가하고 순서를 변경하기가 쉬워집니다. 요소를 조작할 때 쉼표를 추가하거나 삭제할 필요가 없습니다.
  • 예를 들어 객체 초기화 식과 같은 코드 생성이 단순해집니다. 마지막 요소 뒤에도 쉼표가 올 수 있기 때문입니다.

후행 쉼표는 전적으로 선택 사항이며, 사용하지 않아도 코드는 정상 작동합니다. Kotlin 스타일 가이드에서는 선언부(declaration site)에서 후행 쉼표 사용을 권장하며, 호출부(call site)에서는 재량에 맡깁니다.

IntelliJ IDEA 포매터에서 후행 쉼표를 활성화하려면 Settings/Preferences | Editor | Code Style | Kotlin으로 이동하여 Other 탭을 열고 Use trailing comma 옵션을 선택하세요.

열거형(Enumerations) ​

kotlin
enum class Direction {
    NORTH,
    SOUTH,
    WEST,
    EAST, // 후행 쉼표
}

값 인자 ​

kotlin
fun shift(x: Int, y: Int) { /*...*/ }
shift(
    25,
    20, // 후행 쉼표
)
val colors = listOf(
    "red",
    "green",
    "blue", // 후행 쉼표
)

클래스 프로퍼티 및 매개변수 ​

kotlin
class Customer(
    val name: String,
    val lastName: String, // 후행 쉼표
)
class Customer(
    val name: String,
    lastName: String, // 후행 쉼표
)

함수 값 매개변수 ​

kotlin
fun powerOf(
    number: Int, 
    exponent: Int, // 후행 쉼표
) { /*...*/ }
constructor(
    x: Comparable<Number>,
    y: Iterable<Number>, // 후행 쉼표
) {}
fun print(
    vararg quantity: Int,
    description: String, // 후행 쉼표
) {}

선택적 타입이 있는 매개변수(세터 포함) ​

kotlin
val sum: (Int, Int, Int) -> Int = fun(
    x,
    y,
    z, // 후행 쉼표
): Int {
    return x + y + x
}
println(sum(8, 8, 8))

인덱싱 접미사 ​

kotlin
class Surface {
    operator fun get(x: Int, y: Int) = 2 * x + 4 * y - 10
}
fun getZValue(mySurface: Surface, xValue: Int, yValue: Int) =
    mySurface[
        xValue,
        yValue, // 후행 쉼표
    ]

람다의 매개변수 ​

kotlin
fun main() {
    val x = {
            x: Comparable<Number>,
            y: Iterable<Number>, // 후행 쉼표
        ->
        println("1")
    }
    println(x)
}

when 엔트리 ​

kotlin
fun isReferenceApplicable(myReference: KClass<*>) = when (myReference) {
    Comparable::class,
    Iterable::class,
    String::class, // 후행 쉼표
        -> true
    else -> false
}

컬렉션 리터럴(어노테이션 내) ​

kotlin
annotation class ApplicableFor(val services: Array<String>)
@ApplicableFor([
    "serializer",
    "balancer",
    "database",
    "inMemoryCache", // 후행 쉼표
])
fun run() {}

타입 인자 ​

kotlin
fun <T1, T2> foo() {}
fun main() {
    foo<
            Comparable<Number>,
            Iterable<Number>, // 후행 쉼표
            >()
}

타입 매개변수 ​

kotlin
class MyMap<
        MyKey,
        MyValue, // 후행 쉼표
        > {}

구조 분해 선언 ​

kotlin
data class Car(val manufacturer: String, val model: String, val year: Int)
val myCar = Car("Tesla", "Y", 2019)
val (
    manufacturer,
    model,
    year, // 후행 쉼표
) = myCar
val cars = listOf<Car>()
fun printMeanValue() {
    var meanValue: Int = 0
    for ((
        _,
        _,
        year, // 후행 쉼표
    ) in cars) {
        meanValue += year
    }
    println(meanValue/cars.size)
}
printMeanValue()

문서 주석 ​

길이가 긴 문서 주석의 경우 여는 /**를 별도의 줄에 배치하고 이후의 각 줄은 별표(*)로 시작합니다.

kotlin
/**
 * This is a documentation comment
 * on multiple lines.
 */

짧은 주석은 한 줄로 배치할 수 있습니다.

kotlin
/** This is a short documentation comment. */

일반적으로 @param 및 @return 태그의 사용은 피하세요. 대신 매개변수 및 반환 값에 대한 설명을 문서 주석에 직접 통합하고, 매개변수가 언급되는 곳마다 링크를 추가하세요. @param 및 @return은 본문의 흐름에 맞지 않는 긴 설명이 필요한 경우에만 사용하세요.

kotlin
// 이렇게 하지 마세요:

/**
 * Returns the absolute value of the given number.
 * @param number The number to return the absolute value for.
 * @return The absolute value.
 */
fun abs(number: Int): Int { /*...*/ }

// 대신 이렇게 하세요:

/**
 * Returns the absolute value of the given [number].
 */
fun abs(number: Int): Int { /*...*/ }

불필요한 구문 피하기 ​

일반적으로 Kotlin에서 특정 구문 구조가 선택 사항이고 IDE에 의해 중복(redundant)으로 강조 표시되는 경우 코드에서 이를 생략해야 합니다. 단지 "명확성을 위해" 불필요한 구문 요소를 코드에 남겨두지 마세요.

Unit 반환 타입 ​

함수가 Unit을 반환하는 경우 반환 타입을 생략해야 합니다.

kotlin
fun foo() { // 여기서 ": Unit"은 생략됨

}

세미콜론 ​

가능한 한 세미콜론을 생략하세요.

문자열 템플릿 ​

문자열 템플릿에 단순 변수를 삽입할 때는 중괄호를 사용하지 마세요. 더 긴 표현식에만 중괄호를 사용하세요.

kotlin
println("$name has ${children.size} children")

달러 기호 문자 $를 문자열 리터럴로 취급하려면 다중 달러 문자열 보간법(multi-dollar string interpolation)을 사용하세요.

kotlin
val KClass<*>.jsonSchema : String
    get() = $$"""
        {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "$id": "https://example.com/product.schema.json",
            "$dynamicAnchor": "meta",
            "title": "$${simpleName ?: qualifiedName ?: "unknown"}",
            "type": "object"
        }
        """

언어 기능의 관용적 사용 ​

불변성 ​

가변 데이터보다는 불변 데이터를 선호하세요. 로컬 변수와 프로퍼티는 초기화 후 수정되지 않는 경우 항상 var보다는 val로 선언하세요.

수정되지 않는 컬렉션을 선언할 때는 항상 불변 컬렉션 인터페이스(Collection, List, Set, Map)를 사용하세요. 팩토리 함수를 사용하여 컬렉션 인스턴스를 생성할 때는 가능하면 항상 불변 컬렉션 타입을 반환하는 함수를 사용하세요.

kotlin
// 나쁨: 변경되지 않을 값에 가변 컬렉션 타입 사용
fun validateValue(actualValue: String, allowedValues: HashSet<String>) { ... }

// 좋음: 대신 불변 컬렉션 타입 사용
fun validateValue(actualValue: String, allowedValues: Set<String>) { ... }

// 나쁨: arrayListOf()는 가변 컬렉션 타입인 ArrayList<T>를 반환함
val allowedValues = arrayListOf("a", "b", "c")

// 좋음: listOf()는 List<T>를 반환함
val allowedValues = listOf("a", "b", "c")

기본 매개변수 값 ​

오버로드된 함수를 선언하기보다는 기본 매개변수 값을 가진 함수를 선언하는 것이 좋습니다.

kotlin
// 나쁨
fun foo() = foo("a")
fun foo(a: String) { /*...*/ }

// 좋음
fun foo(a: String = "a") { /*...*/ }

타입 별칭 ​

코드베이스에서 여러 번 사용되는 함수형 타입이나 타입 매개변수가 있는 타입이 있는 경우, 해당 타입에 대한 타입 별칭(Type alias)을 정의하는 것이 좋습니다.

kotlin
typealias MouseClickHandler = (Any, MouseEvent) -> Unit
typealias PersonIndex = Map<String, Person>

이름 충돌을 피하기 위해 private 또는 internal 타입 별칭을 사용하는 경우, 패키지 및 임포트에서 언급된 import ... as ... 방식을 선호하세요.

람다 매개변수 ​

짧고 중첩되지 않은 람다에서는 매개변수를 명시적으로 선언하는 대신 it 규칙을 사용하는 것이 좋습니다. 매개변수가 있는 중첩된 람다에서는 항상 매개변수를 명시적으로 선언하세요.

람다에서의 반환 ​

람다에서 여러 레이블이 지정된 반환(labeled return)을 사용하는 것을 피하세요. 단일 종료 지점을 갖도록 람다를 재구성하는 것을 고려하세요. 그것이 불가능하거나 충분히 명확하지 않다면 람다를 익명 함수로 변환하는 것을 고려하세요.

람다의 마지막 문장에는 레이블이 지정된 반환을 사용하지 마세요.

명명된 인자 ​

메서드가 동일한 원시(primitive) 타입의 매개변수를 여러 개 받거나 Boolean 타입의 매개변수를 받는 경우, 문맥상 모든 매개변수의 의미가 완전히 명확하지 않다면 명명된 인자(Named argument) 구문을 사용하세요.

kotlin
drawSquare(x = 10, y = 10, width = 100, height = 100, fill = true)

조건문 ​

try, if, when의 표현식 형태를 사용하는 것이 좋습니다.

kotlin
return if (x) foo() else bar()
kotlin
return when(x) {
    0 -> "zero"
    else -> "nonzero"
}

위의 코드는 다음 코드보다 선호됩니다.

kotlin
if (x)
    return foo()
else
    return bar()
kotlin
when(x) {
    0 -> return "zero"
    else -> return "nonzero"
}

if 대 when ​

이진 조건에는 when 대신 if를 사용하는 것이 좋습니다. 예를 들어 when 대신 다음 if 구문을 사용하세요.

kotlin
if (x == null) ... else ...

다음과 같은 형태 대신 사용합니다.

kotlin
when (x) {
    null -> // ...
    else -> // ...
}

선택지가 3개 이상인 경우에는 when을 사용하는 것이 좋습니다.

when 표현식의 가드 조건 ​

가드 조건(Guard conditions)이 있는 when 표현식이나 문에서 여러 불리언 표현식을 결합할 때는 괄호를 사용하세요.

kotlin
when (status) {
    is Status.Ok if (status.info.isEmpty() || status.info.id == null) -> "no information"
}

다음 대신 사용합니다.

kotlin
when (status) {
    is Status.Ok if status.info.isEmpty() || status.info.id == null -> "no information"
}

조건문에서의 널 허용 Boolean 값 ​

조건문에서 널 허용(Nullable) Boolean을 사용해야 하는 경우 if (value == true) 또는 if (value == false) 검사를 사용하세요.

루프 ​

루프보다는 고차 함수(filter, map 등)를 사용하는 것이 좋습니다. 예외: forEach(forEach의 수신 객체가 널 허용이거나 forEach가 더 긴 호출 체인의 일부로 사용되지 않는 한, 일반적인 for 루프를 사용하는 것이 좋습니다).

여러 고차 함수를 사용하는 복잡한 표현식과 루프 중에서 선택할 때는 각 경우에 수행되는 연산의 비용을 이해하고 성능 고려 사항을 염두에 두세요.

범위 루프 ​

상한이 배제된 범위를 반복할 때는 ..< 연산자를 사용하세요.

kotlin
for (i in 0..n - 1) { /*...*/ }  // 나쁨
for (i in 0..<n) { /*...*/ }  // 좋음

문자열 ​

문자열 연결(concatenation)보다는 문자열 템플릿을 선호하세요.

일반 문자열 리터럴에 \n 이스케이프 시퀀스를 포함하는 것보다 여러 줄 문자열을 선호하세요.

여러 줄 문자열에서 들여쓰기를 유지하려면, 결과 문자열에 내부 들여쓰기가 필요하지 않을 때는 trimIndent를 사용하고, 내부 들여쓰기가 필요한 경우에는 trimMargin을 사용하세요.

kotlin
fun main() {
    println("""
     Not
     trimmed
     text
     """
    )

    println("""
     Trimmed
     text
     """.trimIndent()
    )

    println()

    val a = """Trimmed to margin text:
            |if(a > 1) {
            |    return a
            |}""".trimMargin()

   println(a)
}

Java와 Kotlin 여러 줄 문자열의 차이점에 대해 알아보세요.

함수 대 프로퍼티 ​

일부 시나리오에서는 인자가 없는 함수와 읽기 전용 프로퍼티가 상호 대체 가능할 수 있습니다. 의미론적으로는 유사하지만, 어느 것을 선호해야 하는지에 대한 몇 가지 스타일 규칙이 있습니다.

기저의 알고리즘이 다음과 같을 때 함수보다 프로퍼티를 선호하세요.

  • 예외를 던지지 않는다.
  • 계산 비용이 적게 든다(또는 첫 실행 시 캐시된다).
  • 객체 상태가 변경되지 않았다면 호출 간에 동일한 결과를 반환한다.

확장 함수 ​

확장 함수를 아낌없이 활용하세요. 주로 특정 객체에 대해 작동하는 함수가 있을 때마다, 해당 객체를 수신 객체(Receiver)로 받는 확장 함수로 만드는 것을 고려하세요. API 오염을 최소화하려면 확장 함수의 가시성을 적절하게 제한하세요. 필요에 따라 로컬 확장 함수, 멤버 확장 함수 또는 private 가시성을 가진 최상위 확장 함수를 사용하세요.

중위 함수 ​

두 객체가 유사한 역할을 수행할 때만 함수를 infix로 선언하세요. 좋은 예: and, to, zip. 나쁜 예: add.

수신 객체를 변경(mutate)하는 메서드는 infix로 선언하지 마세요.

팩토리 함수 ​

클래스에 대한 팩토리 함수를 선언하는 경우 클래스 자체와 동일한 이름을 부여하지 마세요. 팩토리 함수의 동작이 특별한 이유를 명확히 알 수 있는 구별되는 이름을 사용하는 것이 좋습니다. 특별한 의미가 전혀 없는 경우에만 클래스와 동일한 이름을 사용할 수 있습니다.

kotlin
class Point(val x: Double, val y: Double) {
    companion object {
        fun fromPolar(angle: Double, radius: Double) = Point(...)
    }
}

서로 다른 상위 클래스 생성자를 호출하지 않으며 기본값을 가진 매개변수를 포함하는 단일 생성자로 줄일 수 없는 여러 오버로드된 생성자가 있는 객체의 경우, 오버로드된 생성자를 팩토리 함수로 대체하는 것이 좋습니다.

플랫폼 타입 ​

플랫폼 타입의 표현식을 반환하는 공개 함수/메서드는 해당 Kotlin 타입을 명시적으로 선언해야 합니다.

kotlin
fun apiCall(): String = MyJavaApi.getProperty("name")

플랫폼 타입의 표현식으로 초기화되는 모든 프로퍼티(패키지 수준 또는 클래스 수준)는 해당 Kotlin 타입을 명시적으로 선언해야 합니다.

kotlin
class Person {
    val name: String = MyJavaApi.getProperty("name")
}

플랫폼 타입의 표현식으로 초기화되는 로컬 값에는 타입 선언이 있을 수도 있고 없을 수도 있습니다.

kotlin
fun main() {
    val name = MyJavaApi.getProperty("name")
    println(name)
}

범위 지정 함수 apply/with/run/also/let ​

Kotlin은 주어진 객체의 컨텍스트에서 코드 블록을 실행할 수 있는 일련의 함수를 제공합니다: let, run, with, apply, also. 상황에 맞는 적절한 범위 지정 함수(Scope function)를 선택하는 방법에 대한 지침은 범위 지정 함수를 참조하세요.

라이브러리를 위한 코딩 컨벤션 ​

라이브러리를 작성할 때는 API 안정성을 보장하기 위해 추가적인 규칙을 따르는 것이 좋습니다.

  • 멤버 가시성을 항상 명시적으로 지정하세요(선언이 의도치 않게 공개 API로 노출되는 것을 방지하기 위함).
  • 함수의 반환 타입과 프로퍼티 타입을 항상 명시적으로 지정하세요(구현이 변경될 때 반환 타입이 실수로 변경되는 것을 방지하기 위함).
  • 새로운 문서화가 필요 없는 재정의(override)를 제외한 모든 공개 멤버에 대해 KDoc 주석을 제공하세요(라이브러리 문서 생성을 지원하기 위함).

라이브러리용 API를 작성할 때 고려해야 할 모범 사례 및 아이디어에 대한 자세한 내용은 라이브러리 작성자를 위한 가이드라인에서 확인하세요.