[Kotlin] 코틀린 기본 문법(2) - 코틀린 연산자와 표현식, 제어 흐름, 함수와 람다

코틀린의 표현식 구문

val result = 1 + 2

연산자, 피연산자, 할당으로 구성

 

산술 연산자

+

-

*

/

%

 

증강 할당 연산자

+=

-=

*=

/=

%=

 

증가 / 감소 연산자

x++

x--

++x

--x

 

등치 연산자

==

>

>=

<

<=

!=

 

부울 논리 연산자

!

&&

||

 

범위 연산자

x..y

1..5 이면 1, 2, 3, 4, 5를 말한다.

 

비트와이즈 연산자

x.inv()

x.and(y)

x.or(y)

x.xor(y)

x.shl(1)

x.shr(1)

 

반복 제어 흐름

for (index in 1..5) {
    // 1부터 5까지 for문
}

for (index in "hello") {
    // index 변수는 모두 "hello"
}

for (index in 5 downTo 1) {
    // 5부터 1까지 거꾸로 for문
}

for (index in 1 until 5) {
    // index in 1..5랑 동일
}

for (index in 0 until 100 step 10) {
    // 0부터 100까지 10개씩 for문
}

 

while 루프

while (index < 10) {
    // index 10까지 while
}

do {
    // do while문
} while (index < 10)

outerloop@ for (i in 1..100) {
    // code
    
    for (j in 1..100) {
        // code
        
        if (j == 10) break@outerloop  //라벨을 사용해서 해당 라벨의 반복문 탈출 가능
    }
}

 

조건부 제어 흐름

// 기본적인 반복문
if (x > y)
    largest = x
else
    largest = y

// 위와 같은 표현
val largest = if (x > y) x else y

// Switch 구문과 유사
when (x) {
    1 -> // code
    2 -> // code
    3 -> // code
    else -> //code
}

 

함수 선언 및 함수 호출

// 함수 선언
fun functionName(name: String, count: Int): String {
    retrun "$count is $name"
}

// 함수 호출
functionName("Sangyoon", 10)

 

단일 표현식 함수

// 아래 3가지 경우 모두 동일
fun multiply(x: Int, y: Int): Int {
    return x * y
}

fun multiply(x: Int, y: Int): Int = x * y

fun multiply(x: Int, y: Int) = x * y

 

로컬 함수

로컬 함수는 다른 함수 안에 포함된 함수를 뜻한다. 로컬 함수는 해당 함수를 포함한 함수가 가진 모든 변수에 접근 가능하다.

fun main() {
    val name = "Sangyoon"
    val count = 10
    
    fun sub() {
        println(name)
    }
    
    sub()
}

 

반환값 다루기

// 동일 코드이다.
val message = functionName("Sangyoon", 10)

val message = functionName(name = "Sangyoon", count = 10)

 

함수 파라미터

// 함수 파라미터의 기본 값을 선언을 할 수 있다.
fun functionName(name: String = "Unknown", count: Int = 0): String {
    retrun "$count is $name"
}

// 함수 파라미터의 값을 가변으로 선언할 수도 있다.
fun functionName(vararg strings: String) {
    for (string in strings) {
        println(string)
    }
}

functionName("one", "two", "three")

 

람다 표현식

람다는 자급자족하는 함수 블록이다. 기본적인 람다 표현식은 다음과 같다.

val multiply = { val1: Int, val2: Int ->
    val1 * val2
}
val result = multiply(10, 20)

표현식의 맨 마지막에 인수를 직접 전달해 실핼할 수 있다.

val result = { val1: Int, val2: Int ->
    val1 * val2
}(10, 20)

람다 안의 마지막 표현식은 반환값으로 이용된다. 함수와 달리 람다는 return문을 제공하지 않는다.

마지막의 표현식이 없는 경우에는 해당 값을 람다의 마지막 항목으로 선언하기만 하면 그 값을 반환한다.

val result = {
    println("hello")
    true
}()

val message = {
    println("hello")
    "Goodbye"
}()

 

고차 함수

함수나 람다를 파라미터로 받거나 결과값으로 반환하는 함수를 고차 함수라고 한다.

함수를 파라미터로 받기 위해서는 파라미터로 받을 수 있는 함수 타입만 선언하면 된다.

fun inchesToFeet (inches: Double): Double {
    return inches * 0.0833333
}

fun inchesToYards (inches: Double): Double {
    return inches * 0.0277778
}

fun outputConverstion(converterFunc: (Double) -> Double, value: Double) {
    val result = converterFunc(value)
    println("$result")
}

outputConversion(::inchesToFeet, 22.45)
outputConversion(::inchesToTards, 22.45)

 

 

코틀린 기본 문법(1) - 코틀린 데이터 타입, 변수, 널 허용

코틀린 기본 문법(2) - 코틀린 연산자와 표현식, 제어 흐름, 함수와 람다

코틀린 기본 문법(3) - 코틀린 객체지향 프로그래밍, 상속과 서브클래싱