[Kotlin] 기본 문법 (함수, 변수, 문자열 템플릿, 조건문, 제어문, Nullable, 자동타입 반환)

1. 함수 정의

fun sum(a: Int, b: Int) : Int {
    return a + b
}

fun sum2(a: Int, b: Int) = a + b // 함수의 처리가 식(Expression)인 경우 return 생략 가능

fun printKotlin() : Unit {
    // 함수의 리턴할 값이 없을 경우 Unit(Singleton Object)로 return
    // Unit : Java의 void 리턴 역활
    println("Hello Kotlin!")
}

fun printKotlin2() {
    // Unit은 생략 가능
    println("Hello Kotlin2!")
}

fun main(args: Array<String>) {
    println(sum(5, 10))
    println(sum2(5, 10))
    printKotlin()
    printKotlin2()
}

2. 변수 정의

// val : 읽기 전용 변수(final 변수)
// var : 읽기/쓰가 가능한 변수
val a : Int = 1     // 즉시 할당
val b = 2           // Int 타입으로 추론
var c = 5

fun main(args: Array<String>) {
    c += 1
    println("val a = $a")
    println("val b = $b")
    println("var c = $c")
}

3.  문자열 템플릿

// String Interpolation : 문자열 보간법
var a1 = 1
val s1 = "a1 is $a1"
var s2 : String = ""

fun main(args: Array<String>) {
    a1 = 2
    s2 = "${s1.replace("is", "was")}, but now is $a1"

    println("s1 = $s1")
    println("s2 = $s2")
}

4. 조건문, 제어문

val l = 123L
val d = 12.37

fun maxOf(a : Int, b : Int) : Int {
    // if문을 사용한 조건문 함수
    if (a > b) {
        return a
    } else {
        return b
    }
}

fun maxOf2(a: Int, b : Int) = if(a > b) a else b // if문을 사용한 조건식 함수

fun describe(obj: Any) : String =   // when문을 활용한 조건식
        when (obj) {
            1 -> "One"
            "Hello" -> "Greeting"
            is Long -> "Long"
            !is String -> "Not a String"
            else -> "Unknown"
        }

val items = listOf("apple", "banana", "kiwi")
var index = 0

fun whileLoop() {
    // while문을 활용한 loop
    while (index < items.size) {
        println("item at $index is ${items[index]}")
        index++
    }
}


fun forRange() {
    val x = 3

    if (x in 1..10) {
        // in 연산자를 이용하여 숫자의 범위를 체크
        println("firs in range")
    }

    for (i in 1..5) {
        // range를 이용한 for loop
        print(i)
    }
    println()
}


fun collection() {
    val items = listOf("red", "blue", "orange")

    for (i in items) {
        // 컬렉션 + in 연산자를 이용한 loop
        print("$i ")
    }
    println()

    when {
        // 컬렉션 + in 으로 해당 값이 collection에 포함되는지 체크
        "red" in items -> println("빨강")
        "blue" in items -> println("파랑")
    }


    var fruits = listOf("banana", "avocado", "apple", "kiwi")

    // 람다식을 이용해서 collection에 filter, map 등의 연산을 수행할 수 있다.
    fruits
            .filter { it.startsWith("a") } // a로 시작하는 객체를 필터링한다.
            .sortedBy { it } // 지정된 람다식에 의한 순서대로 정렬
            .map { it.toUpperCase() } // 객체를 대문자로 반환
            .forEach {
                println(it)
            }

}


fun main(args: Array<String>) {
    println("if to maxOf = " + maxOf(10, 14))
    println("if to maxOf2 = " + maxOf2(10, 14))

    println("when to describe 1 = " + describe(1))
    println("when to describe Hello = " + describe("Hello"))
    println("when to describe Long = " + describe(l))
    println("when to describe Not String = " + describe(14))
    println("when to describe else = " + describe(d))

    whileLoop()

    forRange()

    collection()

5. Nullable

val str1 = "14"

fun parseInt(str : String) : Int? {
    // 값이 Null 일 수도 있는 경우의 타입을 Nullable(? : 물음표)를
    // 명시해놓으면 Null 안정성을 보장받을 수 있다.
    return str.toInt()
}

fun printProduct(arg1 : String, arg2 : String) {
    // Nullable 타입의 변수를 접근할 때는 반드시 Null 체크를 해야 한다.(생략하게 되면 컴파일 오류가 발생)
    val x : Int ? = parseInt(arg1)
    val y : Int ? = parseInt(arg2)

    if (x != null && y != null) {
        println(x * y)
    } else {
        println("either $arg1 or $arg2 is not a number")
    }
}

fun main(args: Array<String>) {
    println("parseInt1 = " + parseInt(str1))
    printProduct("14", "4")
}

6. 자동 타입 반환

fun getStringLength(obj : Any) : Int? {
    if (obj is String) {
        // obj 타입이 자동으로 String 타입으로 변환된다
        return obj.length
    }
    return null
}

fun main(args: Array<String>) {
    println("getStringLength String = " + getStringLength("추억꽃"))
    println("getStringLength Int = " + getStringLength(14))
}

출처

https://kotlinlang.org/docs/reference/