[Kotlin] 3 - Control Flow

if

• if( 조건문 ) { statements }
• if( 조건문 ) { statements } else { statements }
• if( 조건문 ) { statements } else if(조건문) { statements }
• if( 조건문 ) { statements } else if(조건문) { statements } else { statements }

• kotlin에서 if문은 expression 이다
• expression으로 사용할 때는 반드시 if-else 구조를 사용한다.

 

• 함수의 Body 대신 expression을 사용하면 return을 생략을 할 수 있다.

실습

• 파라미터로 받은 정수의 절대값을 반환하는 함수 abs를 정의하라. 단, 함수 Body 대신 expression을 사용하라.
• 사용자로부터 정수를 입력받아 abs 함수를 사용한 결과를 출력하라

 

 

 

when

• 여러 조건을 처리하는 조건문. expression 으로 사용 가능
• C/Java 에서의 switch와 유사하지만 더 많은 기능을 제공한다.

 

• expression으로 사용할 때는 모든 경우의 수를 다루어야 한다.
  • enum의 경우 모든 경우를 다루면 else 생략 가능.
  • 그 외 모든 경우를 다 다루거나 else 조건 사용

fun main() {
    val b = 3
    val result = when (b) {
        3 -> { print("3") }
        else -> { print("other") }
    }
}

• val b 에 3을 대입해주었는데 타입형을 생략해주었기 때문에 자동으로 int 타입이 된다. int 타입은 -21억 정도에서 +21억 사이까지 할당이 가능하다
• 만약 경우의 수를 정의하지 않으면 result는 null이 되어버리기 때문에 when문의 결과값을 변수에 대입을 해주려면 else문을 사용하거나 모든 경우의 수를 다 정의해주어야 한다.
• 만약 정의를 하지 않으면 'when' expression must be exhaustive, add necessary 'else' branch 오류가 발생한다.

enum class USERTYPE{
    Admin, User
}

fun main() {
    val User:USERTYPE = USERTYPE.User
    val Admin:USERTYPE = USERTYPE.Admin

    val typeStr = when(Admin) {
        USERTYPE.User -> "User"
        USERTYPE.Admin -> "Admin"
    }
  }

• 여기에서는 오류가 발생하지 않는 이유는 enum으로 경우의 수를 Admin, User 두 개로 제한을 하였기 때문에 모든 경우의 수를 다 정의하여 else 문을 쓰지 않아도 된다.

fun main() {

    // 두 가지 이상의 조건을 한번에 처리 가능
    var x = 1
    when (x) {
        0, 1 -> print("x == 0 or x == 1") // 0 또는 1 일때
        else -> print("otherwise") // 그 외의 경우의 수
    }
}

• 두 가지 이상의 조건을 한번에 처리 가능

fun main() {
    println("\n수를 입력 ")
    x = readln().toInt() // x를 int로 입력받는다
    val validNumbers = arrayOf(1, 2, 3); // Array [1, 2, 3]

    when (x) {
        in 1..10 -> print("x is in the range") // 1부터 10까지의 범위
        in validNumbers -> print("x is valid") // [1, 2, 3] 의 배열
        !in 10..20 -> print("x is outside the range") // 10부터 20까지의 범위 안에 있지 않으면
        else -> print("none of the above") // 그 외의 경우의 수
    }
  }

• in 연산자를 이용해 Collection 타입 내에 포함 여부 확인 가능

fun hasPrefix(x: Any) = when(x) {
    is String -> x.startsWith("prefix")
    else -> false
}

fun main() {
    println(hasPrefix("Hello"))
    println(hasPrefix("prefix"))
    println(hasPrefix(12313))
    println(hasPrefix(false))
}

• is 연산자를 이용해 타입 체크 가능

실습

• 사용자로부터 정수를 입력받아 다음과 같이 출력하라.
  • 점수 - 학점
  • 단, 사용자는 0 부터 100 사이의 정수만을 입력한다고 가정한다.
  • 90 이상 100이하: "A"
  • 80 이상 90미만 : "B"
  • 70 이상 80미만 : "C"
  • 60 이상 70미만 : "D"
  • 0 이상 60 미만: "F"

fun check(x: Int) = when(x) {
    in 90..100 -> "A"
    in 80..90 -> "B"
    in 70..80 -> "C"
    in 60..70 -> "D"
    in 0..60 -> "F"
    else -> "0부터 100까지 입력 "
}

fun main() {
    print("점수 입력 : ")
    val score = readln().toInt()
    val res = check(score)
    println("$score - $res")
}

loops

언어별 for문의 목적

• C, Java, Javascript - 특정 횟수 반복

for (int index = 0; index < 10; i++) { }

여기에서 int i 는 for문을 수행하기 위한 보조 자료일 뿐

• Python, Kotlin - Iteration : 특정 대상(데이터의 모음)을 다 살펴보기

처음 부터 끝까지 모두 꺼내보아서 살펴보는것이 목적

Iteration : 처음부터 끝까지 모두 훑어보는 것

for( item in array ) { }

JS(Iteration)

for (let i in array) …

for (let i of array) …

• Iterator를 제공하는 데이터(주로 배열이나 리스트)에 대한 iteration을 제공한다.
• foreach의 동작과 유사하다.

for (item in collection) print(item)
for (item: Int in ints) {
    // ...
}

• iteration된 아이템 말고 Index도 사용하려면 다음 두 방법 중 하나를 사용

// 배열의 index만을 대상으로 loop
for (i in array.indices) {
    println(array[i])
}

// 배열의 index, value를 이용해 loop
for ((index, value) in array.withIndex()) {
    println("the element at $index is $value")
}

• array.indices : 0부터 index-1 까지 자동으로 배열의 모든 index를 할당해줌

fun main() {
    val arr = arrayOf("a", "b", "c")

    for(i in arr) print("$i ")
    println()
    for(i in arr.indices) print("$i ")
    println()
    for((i, v) in arr.withIndex()) print("$i - $v ,")
}

 

• 숫자를 이용한 반복을 위해서는 정수형 Range를 사용한다.

fun main() {
    for (i in 1..3) {
        println(i)
    }

    for (i in 6 downTo 0 step 2)  // for(int i = 6; i>=0; i-2)
        println(i)

    for (i in 1 until 10) // until의 경우 10은 포함 안됨
        print(i)
    println()

    for (i in (1..4).reversed()) print(i)
}

 

while

• while과 do-while을 사용할 수 있다.

 

Returns and jumps

• 3 개의 jump expressions
  • return: 가장 가깝게 감싸고 있는 함수 (또는 익명 함수)를 반환.
  • break: 가장 가깝게 감싸고 있는 loop를 종료.
  • continue: 가장 가깝게 감싸고 있는 loop의 다음 단계로 진행.
• Nothing Type
  • jump expressions, throw의 타입.

break and continue

• Kotlin의 모든 expression은 라벨과 함께 표기될 수 있다.
  • 라벨은 이름@ 형태로 사용하며 문구 앞에 라벨을 먼저 적는다.
  • break와 continue는 적용될 위치를 라벨로 지정할 수 있다.
  • 단, 이 경우 loop 문에 붙은 라벨만을 지정할 수 있다.

fun main() {
    firstloop@ for(i in 0..2) {
        for(j in 0..3) {
            println("$i - $j")
            if(j > 1) break@firstloop
        }
    }
}

 

return to label

• 람다식의 경우 return을 사용할 경우 람다식 외부의 함수가 반환된다.

Lambda Expression

 

Java

(i) → { System.out.println(i); }
test(”a”, (i) → { System.out.println(i); });


JS
(i) ⇒ { console.log(i); }
test(”A”, (i) ⇒ { console.log(i); };


Kotlin

{ i → print(i) }
{ println(it) }
test(”a”) { println(it) }
test2() { println(it) }
test2 { println(it) }

 

파라미터가 딱 하나만 있다면 파라미터를 생략할 수 있고 그때는 it으로 정해짐

람다식 자바 기준

int[] arr = {1, 2, 3}
arr.forEach((item) → {System.out.println(item);});

람다식 코틀린 기준

val arr = arrayOf(1, 2, 3)
arr.forEach { println(it) }

하나도 축약하지 않은 람다식 arr.forEach({it -> println(it)})

• 람다식의 경우 return을 사용할 경우 람다식 외부의 함수가 반환된다.

fun foo () {
    listOf(1, 2, 3, 4, 5).forEach {
        if (it == 3) return // non-local return
        print(it)
        }
    println("이 쪽에 도달 되지 않음")
}

이 람다식에서 return을 사용하면 사용 의도와는 달리 foo( ) 함수 자체가 return이 되어 버린다.

→ 람다식만 return 하고 싶을 때는 라벨을 사용하여야 한다.

생긴 것은 함수처럼 생겼지만 람다식도 expression 이기때문

• 람다식만 return 하고 싶을 때는 라벨을 사용한다. : return 도 expression

명시적 라벨을 붙인 경우

fun foo () {
    listOf(1, 2, 3, 4, 5).forEach lit@ {
        if (it == 3) return@lit // local return 
        print(it)
        }
    println("foo 함수 끝남")
}

묵시적 라벨

fun foo () {
    listOf(1, 2, 3, 4, 5).forEach {
        if (it == 3) return@forEach // local return
        print(it)
        }
    println("foo 함수 끝남")
}

라벨 없이 내부만 return 하고 싶다면 람다식 대신 익명 함수를 사용한다.

fun foo () {
    listOf(1, 2, 3, 4, 5).forEach(fun(value:Int) {
        if (it == 3) return // local retrn
        print(it)
        })
    println("foo 함수 끝남")
}

람다식이 중첩된 경우 라벨을 사용해 원하는 람다식을 return 할 수 있다.

fun foo () {
    run loop@ {
        listOf(1, 2, 3, 4, 5).forEach {
            if (it == 3) return@loop // non - local return
            print(it)
            }
        }    
        println("done with nested loop")
}

• run 함수로 전달된 람다식 안에서 forEach의 람다가 실행되는 형태

예외

• Throwable 클래스를 상속받은 Exception 클래스를 사용한다.
• 발생 시키기

 

• 처리하기

 

• try문은 expression 으로 값을 반환한다.

fun main() {
    val str = readln()

    val value = try {
        str.toInt()
    } catch (e:Exception) {
        println(e.message)
        0
    }

    println(value)
}