코틀린 기초 문법

함수 작성

// 1. 함수 작성
fun foo(): Unit {
    println("hello, world")
}

fun addInt(x: Int, y: Int): Int{
    return x + y
}

fun 함수이름(매개변수: 매개변수타입): 반환값타입 {

}

var vs val

// 2. var vs val
fun foo(){
    val a : Int = 10 // 상수(엄밀히 따지면 아니긴 하지만)
    var b : Int = 9  // 변수
    
    // a = 100 오류발생
    b = 10 // var 재할당 가능

    // 타입 안써줘도 상관 없음
    var c = 10 
    val d = 100
    
    // 변수 선언하자마자 바로 할당하지 않는 경우에는 타입 생략 불가
    var e: String // String 생략 불가능
}

val은 재할당 불가능 var 가능
변수 선언 및 할당이 동시에 일어날 경우 타입 명시 안해도 됨
선언하자마자 할당 안하면 명시해야함

조건문

if (a > b) a else b // Expression

if else 한 줄 처리

when문

    when(score){ // statement 
        0 -> println("0임")
        1 -> println("1임")
        2 -> println("2임")
        else -> println("그 외")
    }

    // when 문은 변수에 담을 수 있지만, else를 반드시 적어줘야 함
    var b = when(score){ // Expression
        0 -> 0
        1 -> 1
        else -> -1
    }

    when (score){
        in 90..100 -> println("A+") // 90, 100도 포함
        in 0 .. 10 -> println("낙제")
        else -> println("그 외")
    }

switch문과 유사. 변수에 담을 수 있지만 그 경우엔 else를 반드시 명시해주어야 함.

in n..m -> n과 m 둘 다 포함

Expression vs Statement

뭘 해서 값을 만들면/반환하면 Expression
이걸 해라!라고 명령만 하면 statement
코틀린의 모든 함수는 Expression - 반환값이 없더라도 Unit을 반환하기 때문에

Array vs List

Array - 배열의 크기가 정해져 있음. 기본적으로 mutable
List - 1. List(수정불가) 2.Mutable List(수정 가능)
+) 동적 배열은 ArrayList 사용함

var arrayList: ArrayList<Int> = arrayListOf();

반복문

    var students: ArrayList<String> = arrayListOf();

	
    for (name in students) {
        println("이름: ${name}")
    }

    var sum: Int = 0
    for (i in 1..5) {
        sum += i
    }

    // 1부터 9까지 출력
    for (i in 1 until 10) {
        sum += i
    }
    
    for ((index, value) in students.withIndex()){
        println("${index}번째 학생 ${value}")
    }

until - to-value는 제외하고 반복

let 함수

    var id: String = "id"

    id.let { 
        id += 1
    }

해당 변수를 람다식 안으로 넘겨줌

? and ?:

    // ? 연산자 - nullable
    var name: String? = null;

    // name이 not null이면 뒤에 메소드 실행, null이면 그냥 null 반환
    var nameUpperCase = name?.toUpperCase();

	val email : String? = null
    email?.let{ // let함수. 해당 변수를 람다식 안으로 넘겨줌. 여기서는 email이 null이 아니면 람다식 안으로 넘겨줌
        println("${email}")
    }


    // ?: 엘비스 프레슬리 연산자 - 기본값 설정
    var lastName : String? = null;
    
    // lastName이 null이 아니면 그걸 반환, null이면 : 뒤에 값 반환
    var fullName = name + " " + (lastName?: "No Last Name");

? 연산자는 null을 허용하고, ?: 연산자는 null이 들어올 시 기본값을 설정해주는 연산자

!! 연산자

fun foo (str: String?){
	val notNull: String = str!!
}

람다 함수

val plus: (Int) -> (Int) = { number -> number + number }
val introduce = { name: String, age: Int ->
    "이름: ${name} 나이: ${age}"    
}

기본 형태
val lamdaName: Type = { parameter -> functionBody }

val calculateGrade : (Int) -> String = { // 무조건 String을 반환해줘야 하기 때문에 else 꼭 필요
    when (it) {
        in 0..40 -> "fail"
        in 41..70 -> "pass"
        in 71.. 100 -> "perfect"
        else -> "Error"
    }
}

println(caculateGrade(80))

확장함수

// String 클래스 확장 함수. 반환값 String
val pizzaIsGreat: String.() -> String = {
    this + "Pizza is great"
}

var a = "She said"
println(a.pizzaIsGreat())

기존에 정의된 클래스에 함수를 추가하는 기능

아래와 같이도 사용 가능

fun extendStr(name: String, age: Int): String {
    val introduce2: String.(Int) -> String = {"이름: ${name} 나이: ${age}"}
    return name.introduce2(age)
}


extendStr("홍길동", 20)

더 자세한 설명: https://codechacha.com/ko/kotlin-extension-functions/

람다 응용

    // 파라미터로 람다 함수를 넘겨줄 수 있음. 
    // 아래는 double형을 받고 boolean을 반환하는 람다함수를 파라미터로 받음
    fun callLamda(lamda: (Double) -> (Boolean)): Boolean {
       return lamda(12.3)
    }


    // 파라미터 number가 4.123와 같은지 다른지를 리턴
    val lamda = { number: Double ->
        number === 4.123
    }

    println(callLamda(lamda))
    println(callLamda { it > 3.2 }) // lambda함수 없이 바로 중괄호로 파라미터에 넘길 수 있음.  it은 하나 들어가는 파라미터를 가리킴
    println(callLamda(){ it > 2 })
    println(callLamda {  it > 1 } ) // 마지막 파라미터가 람다식일 때 소괄호도 생략 가능.

다음과 같은 반환값이 출력됨
false
true
true
true