[Kotlin 기초] 코틀린 기본 문법 - 스코프 함수

 

 

 

10 스코프 함수 (Scope Functions)

 

 

• 코드를 축약해서 표현할 수 있도록 도와주는 함수, 영역 함수
• 사용법은 함수처럼 쓰지 않고 run, let처럼 괄호 없이 일종의 키워드 같이 사용
• lateinit과 함께 Safe Call 남용을 막아주는 역할, 많이 사용
• 객체를 사용할 때 임시로 Scope를 만들어서 편리한 코드 작성을 도와줌
• 스코프 내에서는 객체의 이름을 통해 일일히 참조할 필요 없이 객체를 접근하고 핸들링하는 편리함
• 종류: run, let, apply, also, with

 

---

 

 

스코프 함수 종류

• 자신의 함수 스코프(코드 블록) 안에서 호출한 대상을  this 혹은 it로 대체해서 사용할 수 있음

 

 

let

var list = mutableListOf("Scope", "Function")
list.let { // it -> 생략된 형태. it -> 대신에 target -> 등으로 변경 가능
    val listSize = it.size // 모든 속성과 함수를 it.멤버로 사용할 수 있음
    println("리스트의 길이 let = $listSize")
}

// MutableList의 size 속성을 let 스코프 안에서 it.size로 호출

	var strNum = "10"

    var result = strNum?.let { // 중괄호 안에서는 it으로 활용함
        Integer.parseInt(it)   // 여기서의 it은 strNum
    }

    println(result!!+1)

• 함수 영역 안에서 호출한 대상을 it으로 사용
• it은 생략 불가. 다만 target 등 다른 이름으로 바꿀 수 있음
  
  

 

 

with

	var alphabets = "abcd"

    with(alphabets) {
        var result = subSequence(0,2)   // this.subSequence(0,2)지만 this. 생략
        println(result)
    }

• 중괄호 블록안에 this로 자신의 객체를 전달하고 코드를 수행
• this는 생략해서 사용할 수 있으므로, 반드시 null이 아닐때만 사용하는게 좋음 (run과 달리 null체크 불가)

 

 

run

var list = mutableListOf("Scope", "Function")
list.run {
    val listSize = size
    println("list의 길이 run = $listSize")
}

//MutableList를 run 함수를 사용해서 스코프를 지정한 후, 내부에서 size 프로퍼티를 직접 호출

// 객체에서 호출하지 않는 경우

		var totalPrice = run {
        var computer = 10000
        var mouse = 5000

        computer+mouse
    }
    println("총 가격은 ${totalPrice}입니다")

//객체에서 호출하는 경우

fun main() {
    var student = Student("참새", 10)
    student?.run {     // 똑같이 this를 생략할 수 있는 with과 달리 null체크 가능
        displayInfo()     // student.displayInfo() 지만 this.을 생략함
    }
}

class Student(name: String, age: Int) {
    var name: String
    var age: Int
    
    init {
        this.name = name
        this.age = age
    }
    
    fun displayInfo() {
        println("이름은 ${name} 입니다")
        println("나이는 ${age} 입니다")
    }
}

• 스코프 함수 안에서 호출한 대상을 this로 사용
• with와 달리 null체크를 수행할 수 있으므로 더욱 안전하게 사용가능
• 클래스 내부의 함수를 사용하는 것과 동일한 효과이기 때문에, this를 생략하고 메서드나 프로퍼티 바로 사용 가능

 

 

also

 

fun main() {
    var student = Student("참새", 10)

    var result = student?.also {
        it.age = 50
    }
    result?.displayInfo()
    student.displayInfo()
}

class Student(name: String, age: Int) {
    var name: String
    var age: Int

    init {
        this.name = name
        this.age = age
    }

    fun displayInfo() {
        println("이름은 ${name} 입니다")
        println("나이는 ${age} 입니다")
    }
}

• 중괄호 블록안에 it으로 자신의 객체를 전달하고 객체를 반환
• apply와 함께 자주 사용

 

 

 

apply

 

fun main() {
    var student = Student("참새", 10)

    var result = student?.apply {
        student.age = 50
    }
    result?.displayInfo()
    student.displayInfo()
}

class Student(name: String, age: Int) {
    var name: String
    var age: Int
    
    init {
        this.name = name
        this.age = age
    }
    
    fun displayInfo() {
        println("이름은 ${name} 입니다")
        println("나이는 ${age} 입니다")
    }
}

• 중괄호 블록안에 this로 자신의 객체를 전달하고 객체를 반환
• 주로 객체의 상태를 변화시키고 바로 저장하고 싶을때 사용

 

 

---

 

 

this와 it으로 구분하기

 

this로 사용되는 스코프 함수: run, apply, with

var list = mutableListOf("Scope", "Function")
​
list.apply {
    val listSize = size
    println("리스트의 길이 apply = $listSize")
}
​
with (list){
    val listSize = size
    println("리스트의 길이 with = $listSize")
}

• apply와 with의 사용 예제 / example.apply, with (example)
• 스코프 함수 안에서 this로 사용되기 때문에 메서드나 프로퍼티를 직접 호출

 

💡 호출 대상이 null일 경우?

• with은 스코프 함수지만, 위의 2개와는 다르게 확장(Extension) 함수가 아니기 때문에 일반 함수처럼 사용됨
• 따라서 호출하는 대상이 null일 경우에는 with보다는 apply나 run을 사용하는 것이 효율적
• target?.apply { /* 코드 */ }

 

 

it으로 사용되는 스코프 함수: let, also

var list = mutableListOf("Scope", "Function")
list.let { target -> // it을 target 등과 같이 다른 이름으로 변경 가능
    val listSize = target.size // target으로 변경했기에 멤버 접근은 target.속성
    println("리스트의 길이 let = $listSize")
}
​
list.also {
    val listSize = it.size
    println("리스트의 길이 also = $listSize")
}

•  let과 also의 사용예제 / example.let, example.also

 

 

---

 

 

반환값으로 구분하기

• 동일하게 this로 사용되는 함수라도, 대입 연산자를 사용해서 값을 반환할 경우에는 용도가 달라짐
• 결괏값을 반환할 경우, 스코프가 종료되는 시점에서의 반환값이 다르기 때문에 서로 다른 역할의 스코프 함수가 필요

 

 

호출 대상인 this 자체를 반환하는 스코프 함수: apply, also

var list = mutableListOf("Scope", "Function")
​
val afterApply = list.apply {
    add("Apply")
    count()
}
println("반환값 apply = $afterApply") // 반환값 apply = [Scope, Function, Apply]
​
val afterAlso = list.also {
    it.add("Also")
    it.count()
}
println("반환값 also = $afterAlso") // 반환값 also = [Scope, Function, Apply, Also]

• apply, also를 사용하면 스코프 함수 안에서 코드가 모두 완료된 후 자기 자신을 되돌려 줌
• 다음 예제에서 apply 스코프의 마지막 줄에서 count()를 호출했지만 마지막 코드와 상관없이 그냥 MutableList 자신을 돌려주기 때문에 Scope, Function에 Apply가 추가된 값이 출력됨
• apply 함수는 람다 블록의 마지막 표현식인 count()를 실행하지만 해당 결과를 반환하지 않음. 따라서 afterApply에는 count() 함수의 반환값이 포함되지 않음
• also 함수는 람다 블록의 인자로 전달된 객체를 반환함. 따라서 also 함수 내부에서 count()를 호출하여도 해당 결과가 반환되지 않고 원래의 리스트를 그대로 반환함.

 

 

마지막 실행 코드를 반환하는 스코프 함수: let, run, with

var list = mutableListOf("Scope", "Function")
​
val lastCount = list.let {
    it.add("Run")
    it.count()
}
println("반환값 let = $lastCount") // 반환값 let = 3
​
val lastItem = list.run {
    add("Run")
    get(size-1)
}
println("반환값 run = $lastItem") // 반환값 run = Run
​
val lastItemWith = with(list){
    add("With")
    get(size-1)
}
println("반환값 with = $lastItemWith") // 반환값 with = With

• let, run, with의 결괏값을 반환하는 경우에는 앞의 2개와는 완전히 다른 결과가 나올 수 있음
• 자기 자신이 아닌 스코프의 마지막 코드를 반환
• let 함수:
  let 함수는 람다 블록에 수신 객체를 인자로 전달하고, 람다 블록의 결과를 반환
  람다 블록 내부에서 it을 사용하여 수신 객체에 접근
  첫 번째로 수신 객체인 list에 "Run"을 추가하고, 그 후에 요소 개수를 반환
  따라서 반환값은 추가 후의 리스트의 요소 개수인 3
• run 함수:
  run 함수는 수신 객체의 메서드를 호출하는 형태로 사용
  람다 블록 내부에서 this를 사용하여 수신 객체에 접근
  run 함수의 결과는 람다 블록의 마지막 표현식의 결과
  람다 블록 내부에서 "Run"을 리스트에 추가한 후, 리스트의 마지막 요소를 반환
  따라서 반환값은 추가 후의 리스트의 마지막 요소인 "Run"
• with 함수:
  with 함수는 수신 객체와 함께 호출
  람다 블록 내부에서는 수신 객체를 this를 사용하여 접근할 필요 없이 직접 접근
  with 함수의 결과는 람다 블록의 마지막 표현식의 결과
  with 함수 내부에서 "With"를 리스트에 추가한 후, 리스트의 마지막 요소를 반환
  따라서 반환값은 추가 후의 리스트의 마지막 요소인 "With"

 

 

 

---

 

 

수신객체, 람다와의 관계

 

// 수신객체 자체를 람다의 수신객체로 전달하는 방법
public inline fun <T, R> T.run(block: T.() -> R): R
public inline fun <T> T.apply(block: T.() -> Unit): T
public inline fun <T, R> with(receiver: T, block: T.() -> R): R

// 수신객체를 람다의 파라미터로 전달
public inline fun <T> T.also(block: (T) -> Unit): T
public inline fun <T, R> T.let(block: (T) -> R): R

• T는 수신객체를 의미
• block: 내부는 람다함수의 소스코드
• 수신객체는 it으로 사용할 수 있음, 그러나 모든 수신 객체를 it으로 활용하면 문제가 생길 수 있음
  Child Function에서 Shadow가 되어서 제대로 참조하지 못할 수 있어요
  따라서 it은 다른 이름으로 변경해서 사용하기도 함

 

// Scope Function을 중첩으로 사용할 경우 누가 누구의 범위인지 알수 없다!
// Implicit parameter 'it' of enclosing lambda is shadowed 경고 발생!

data class Person(
	var name: String = "",
	var age: Int? = null,
	var child: Person? = null
)

// 잘못된 예시
Person().also {
	it.name = "한석봉"
	it.age = 40
  val child = Person().also {
	  it.name = "홍길동" // 누구의 it인지 모른다!
    it.age = 10 // 누구의 it인지 모른다!
  }
  it.child = child
}

// 수정한 예시
Person().also {
	it.name = "한석봉"
	it.age = 40
  val child = Person().also { c ->
	  c.name = "홍길동"
    c.age = 10
  }
  it.child = child
}

 

 

	Scope에서 접근방식 this	Scope에서 접근방식 it
블록 수행 결과를 반환	run, with	let
객체 자신을 반환	apply	also