<div id="readability-page-1" class="page"><article itemscope="" itemtype="http://schema.org/Article"><header></header><div><ul>
<li>
<a href="#scope-function">Scope Function</a>
</li>
<li>
<a href="#%EC%A0%95%EC%9D%98">정의</a>
</li>
<li>
<a href="#%EC%9A%94%EC%86%8C">요소</a>
<ul>
<li>
<a href="#%EC%B0%A8%EC%9D%B4%EC%A0%90">차이점</a>
</li>
<li>
<a href="#%ED%95%A8%EC%88%98-%EC%A0%95%EC%9D%98">함수 정의</a>
<ul>
<li><a href="#let">let</a></li>
<li><a href="#run">run</a></li>
<li><a href="#with">with</a></li>
<li><a href="#apply">apply</a></li>
<li><a href="#also">also</a></li>
</ul>
</li>
</ul>
</li>
<li>
<a href="#let-1">let</a>
<ul>
<li>
<a href="#%EC%98%88%EC%A0%9C">예제</a>
<ul>
<li><a href="#let-%EC%82%AC%EC%9A%A9-x">let 사용 X</a></li>
<li><a href="#let-%EC%82%AC%EC%9A%A9-o">let 사용 O</a></li>
<li><a href="#null%EC%9D%B4-%EB%90%A0-%EC%88%98-%EC%97%86%EB%8A%94-%EA%B0%9D%EC%B2%B4%EC%97%90-%EB%8C%80%ED%95%B4-%EA%B3%BC-%EA%B0%99%EC%9D%B4-%EC%82%AC%EC%9A%A9">null이 될 수 없는 객체에 대해 ?.과 같이 사용</a></li>
</ul>
</li>
</ul>
</li>
<li>
<a href="#run-1">run</a>
</li>
<li>
<a href="#with-1">with</a>
</li>
<li>
<a href="#apply-1">apply</a>
</li>
<li>
<a href="#also-1">also</a>
</li>
</ul></div><section itemprop="articleBody"><h2 id="scope-function">Scope Function<a href="#scope-function" aria-label="scope function permalink"></a></h2>
<h2 id="정의">정의<a href="#%EC%A0%95%EC%9D%98" aria-label="정의 permalink"></a></h2>
Kotlin은 객체의 컨텍스트 내에서 오직 코트 블록을 실행하는 여러 함수가 포함되어 있는데, 람다식에서 scope 함수를 호출하면 임시 범위(scope)가 만들어진다. 이 scope에서는 해당 객체의 이름 없이도 접근가능하다.
<h2 id="요소">요소<a href="#%EC%9A%94%EC%86%8C" aria-label="요소 permalink"></a></h2>
<code>Scope 함수</code> 에는 <code>let</code>, <code>run</code>, <code>with</code>, <code>apply</code>, <code>also</code> 가 있는데, 이 다섯 함수는 기본적으로는 같은 것을 한다 : 객체에 있는 코드 블록을 실행하는 함수들이다.
<h2 id="차이점">차이점<a href="#%EC%B0%A8%EC%9D%B4%EC%A0%90" aria-label="차이점 permalink"></a></h2>
차이점은 다음과 같은데, 해당 객체들이 어떻게 코드 블록 내에서 사용 가능하게 되는지와, 전체 표현식의 결과이다.
<h2 id="함수-정의">함수 정의<a href="#%ED%95%A8%EC%88%98-%EC%A0%95%EC%9D%98" aria-label="함수 정의 permalink"></a></h2>
<h3 id="let">let<a href="#let" aria-label="let permalink"></a></h3>
<div data-language="kotlin"><pre><code>public inline fun &lt;T, R&gt; T.let(block: (T) -&gt; R): R {
 contract {
 callsInPlace(block, InvocationKind.EXACTLY_ONCE)
 }
 return block(this)
}
</code></pre></div>
<h3 id="run">run<a href="#run" aria-label="run permalink"></a></h3>
<div data-language="kotlin"><pre><code>public inline fun &lt;T, R&gt; T.run(block: T.() -&gt; R): R {
 contract {
 callsInPlace(block, InvocationKind.EXACTLY_ONCE)
 }
 return block()
}
</code></pre></div>
<h3 id="with">with<a href="#with" aria-label="with permalink"></a></h3>
<div data-language="kotlin"><pre><code>public inline fun &lt;T, R&gt; with(receiver: T, block: T.() -&gt; R): R {
 contract {
 callsInPlace(block, InvocationKind.EXACTLY_ONCE)
 }
 return receiver.block()
}</code></pre></div>
<h3 id="apply">apply<a href="#apply" aria-label="apply permalink"></a></h3>
<div data-language="kotlin"><pre><code>public inline fun &lt;T&gt; T.apply(block: T.() -&gt; Unit): T {
 contract {
 callsInPlace(block, InvocationKind.EXACTLY_ONCE)
 }
 block()
 return this
}</code></pre></div>
<h3 id="also">also<a href="#also" aria-label="also permalink"></a></h3>
<div data-language="kotlin"><pre><code>public inline fun &lt;T&gt; T.also(block: (T) -&gt; Unit): T {
 contract {
 callsInPlace(block, InvocationKind.EXACTLY_ONCE)
 }
 block(this)
 return this
}</code></pre></div>
<table>
<thead>
<tr>
<th>함수</th>
<th>객체 참조</th>
<th>반환 값</th>
<th>확장 함수 여부</th>
</tr>
</thead>
<tbody>
<tr>
<td>let</td>
<td>it</td>
<td>람다 결과</td>
<td>O</td>
</tr>
<tr>
<td>run</td>
<td>this</td>
<td>람다 결과</td>
<td>O</td>
</tr>
<tr>
<td>run</td>
<td>-</td>
<td>람다 결과</td>
<td>X : context 없이 호출</td>
</tr>
<tr>
<td>with</td>
<td>this</td>
<td>람다 결과</td>
<td>X : context 객체를 인수로 사용</td>
</tr>
<tr>
<td>apply</td>
<td>this</td>
<td>context 객체</td>
<td>O</td>
</tr>
<tr>
<td>also</td>
<td>it</td>
<td>context 객체</td>
<td>O</td>
</tr>
</tbody>
</table>
<h2 id="let-1">let<a href="#let-1" aria-label="let 1 permalink"></a></h2>
<ul>
<li>
let 함수를 사용하면 null이 될 수 있는 식을 더 쉽게 다룰 수 있다.
</li>
<li>
let 함수는 자신의 수신 객체를 인자로 전달받은 람다에게 넘기고, 널이 될 수 있는 값에 대해 안전한 호출 구문을 사용해 let을 호출하되, 널이 될 수 없는 타입을 인자로 받는 람다를 let에 전달한다. 즉 지정된 값이 null이 아닌 경우에 코드를 실행해야 하는 경우 유용
</li>
<li>
수신 객체는 <code>it</code>이라는 인자로 사용할 수 있고, 람다 결과가 return 값이다.
</li>
<li>
let은 호출 체인들의 결과에 대해 하나 이상의 함수를 호출하는 데 사용할 수 있다. 예를들어 다음 코드는 Collection에 대한 두 작업의 결과를 리턴한다.
</li>
</ul>
<h2 id="예제">예제<a href="#%EC%98%88%EC%A0%9C" aria-label="예제 permalink"></a></h2>
<h3 id="let-사용-x">let 사용 X<a href="#let-%EC%82%AC%EC%9A%A9-x" aria-label="let 사용 x permalink"></a></h3>
<div data-language="kotlin"><pre><code>val numbers = mutableListOf("one", "two", "three", "four", "five")
val resultList = numbers.map { it.length }.filter { it &gt; 3 }
println(resultList) </code></pre></div>
<h3 id="let-사용-o">let 사용 O<a href="#let-%EC%82%AC%EC%9A%A9-o" aria-label="let 사용 o permalink"></a></h3>
<div data-language="kotlin"><pre><code>val numbers = mutableListOf("one", "two", "three", "four", "five")
numbers.map { it.length }.filter { it &gt; 3 }.let {
 println(it)
}

// 람다 대신 메서드 참조 (::) 사용

val numbers = mutableListOf("one", "two", "three", "four", "five")
numbers.map { it.length }.filter { it &gt; 3 }.let(::println)</code></pre></div>
<h3 id="null이-될-수-없는-객체에-대해-과-같이-사용">null이 될 수 없는 객체에 대해 ?.과 같이 사용<a href="#null%EC%9D%B4-%EB%90%A0-%EC%88%98-%EC%97%86%EB%8A%94-%EA%B0%9D%EC%B2%B4%EC%97%90-%EB%8C%80%ED%95%B4-%EA%B3%BC-%EA%B0%99%EC%9D%B4-%EC%82%AC%EC%9A%A9" aria-label="null이 될 수 없는 객체에 대해 과 같이 사용 permalink"></a></h3>
<div data-language="kotlin"><pre><code>val str: String = "Hello"
val length = str?.let {
 println("let() called on $it)
 processNonNullString(it) 
 it.length
}</code></pre></div>
-&gt; null이 아닐 때만 실행
<h2 id="run-1">run<a href="#run-1" aria-label="run 1 permalink"></a></h2>
<ul>
<li>수신 객체는 <code>this</code>로 사용가능하고, return 값은 람다의 결과이다.</li>
<li><code>run</code>은 <code>with</code> 와 같은 일을 하지만 <code>let</code>과 같이 수신 객체에 대한 확장함수이다.</li>
<li><code>run</code> 은 람다가 객체의 초기화와 return값에 대한 계산을 모두 할 경우 유용하다.</li>
<li>확장함수이기 때문이 <code>.?</code>을 붙여 non-null 제약을 걸 수 있다.</li>
</ul>
<div data-language="kotlin"><pre><code>val square = run {
 val width= 10
 val height = 10
 Square(name, age)
}</code></pre></div>
<h2 id="with-1">with<a href="#with-1" aria-label="with 1 permalink"></a></h2>
<ul>
<li>
<code>with</code> 는 확장함수가 아니므로 수신 객체를 인자로 전달하지만, 람다 내부에서 <code>this</code> 로 사용가능하다. return 값은 람다 실행 결과이다.
</li>
<li>
람다 결과과 필요하지 않거나 제공하지 않고, 수신 객체 내에서 함수를 호출하는 경우 <code>with</code> 를 사용하는 것이 좋다.
<ul>
<li><code>with this object, do the following.</code></li>
</ul>
</li>
</ul>
<div data-language="kotlin"><pre><code>val numbers = mutableListOf("one", "two", "three", "four", "five")
with(numbers) {
 println("'with' is called with argument $this")
 println("It contains $size elements")
}
// 호출 결과는 사용하지 않는다.</code></pre></div>
<h2 id="apply-1">apply<a href="#apply-1" aria-label="apply 1 permalink"></a></h2>
<ul>
<li>수신 객체는 <code>this</code>로 사용가능하고, return 값은 객체 자신이다.</li>
<li>값을 반환하지 않고, 수신 객체의 멤버가 주로 연산할 때 <code>apply</code> 를 사용하면 좋다.</li>
<li><code>Builder</code> 패언과 동일한 용도로 사용된다.</li>
<li>대표적으로 객체를 초기화 할 때 사용</li>
</ul>
<div data-language="kotlin"><pre><code>val user = User(name = "yeseul").apply {
 age = 27
}</code></pre></div>
<h2 id="also-1">also<a href="#also-1" aria-label="also 1 permalink"></a></h2>
<ul>
<li><code>also</code> 는 확장함수 이므로 수신 객체를 <code>this</code> 를 사용한다. 그러나 코드블럭 내에서 <code>this</code> 를 파라미터로 입력하므로, <code>it</code> 을 통해 프로퍼티에 접근할 수 있다.</li>
<li>반환 결과가 객체 자신이며, <code>Builder</code> 패턴과 동일하게 사용된다.</li>
<li>객체의 속성을 전혀 사용하지 않거나 변경하지 않는 경우 사용하면 좋다. 객체의 유효성 확인, 로그, 디버깅 등의 목적으로 사용</li>
</ul>
<div data-language="kotlin"><pre><code>val numbers = mutableListOf("one", "two", "three")
numbers
 .also { println("The list elements before adding new one: $it") }
 .add("four")</code></pre></div>
<hr>
출처
<ul>
<li>Kotlin In Action</li>
<li>kotlin 공식 문서</li>
<li><a href="https://mycool0905.github.io/kotlin/2020/12/15/kotlin-scope-function.html" target="_blank" rel="nofollow noopener noreferrer">https://mycool0905.github.io/kotlin/2020/12/15/kotlin-scope-function.html</a></li>
</ul></section></article></div>

Seulog💘

이예슬

Scope Function
정의
Kotlin은 객체의 컨텍스트 내에서 오직 코트 블록을 실행하는 여러 함수가 포함되어 있는데, 람다식에서 scope 함수를 호출하면 임시 범위(scope)가 만들어진다. 이 scope에서는 해당 객체의 이름 없이도 접근가능하다.
요소
Scope 함수 에는 let, run, with, apply, also 가 있는데, 이 다섯 함수는 기본적으로는 같은 것을 한다 : 객체에 있는 코드 블록을 실행하는 함수들이다.
차이점
차이점은 다음과 같은데, 해당 객체들이 어떻게 코드 블록 내에서 사용 가능하게 되는지와, 전체 표현식의 결과이다.
함수 정의
let
public inline fun <T, R> T.let(block: (T) -> R): R {
 contract {
 callsInPlace(block, InvocationKind.EXACTLY_ONCE)
 }
 return block(this)
}
run
public inline fun <T, R> T.run(block: T.() -> R): R {
 contract {
 callsInPlace(block, InvocationKind.EXACTLY_ONCE)
 }
 return block()
}
with
public inline fun <T, R> with(receiver: T, block: T.() -> R): R {
 contract {
 callsInPlace(block, InvocationKind.EXACTLY_ONCE)
 }
 return receiver.block()
}
apply
public inline fun <T> T.apply(block: T.() -> Unit): T {
 contract {
 callsInPlace(block, InvocationKind.EXACTLY_ONCE)
 }
 block()
 return this
}
also
public inline fun <T> T.also(block: (T) -> Unit): T {
 contract {
 callsInPlace(block, InvocationKind.EXACTLY_ONCE)
 }
 block(this)
 return this
}
함수
객체 참조
반환 값
확장 함수 여부
let
it
람다 결과
O
run
this
람다 결과
O
run
-
람다 결과
X : context 없이 호출
with
this
람다 결과
X : context 객체를 인수로 사용
apply
this
context 객체
O
also
it
context 객체
O
let
let 함수를 사용하면 null이 될 수 있는 식을 더 쉽게 다룰 수 있다.
let 함수는 자신의 수신 객체를 인자로 전달받은 람다에게 넘기고, 널이 될 수 있는 값에 대해 안전한 호출 구문을 사용해 let을 호출하되, 널이 될 수 없는 타입을 인자로 받는 람다를 let에 전달한다. 즉 지정된 값이 null이 아닌 경우에 코드를 실행해야 하는 경우 유용
수신 객체는 it이라는 인자로 사용할 수 있고, 람다 결과가 return 값이다.
let은 호출 체인들의 결과에 대해 하나 이상의 함수를 호출하는 데 사용할 수 있다. 예를들어 다음 코드는 Collection에 대한 두 작업의 결과를 리턴한다.
예제
let 사용 X
val numbers = mutableListOf("one", "two", "three", "four", "five")
val resultList = numbers.map { it.length }.filter { it > 3 }
println(resultList) 
let 사용 O
val numbers = mutableListOf("one", "two", "three", "four", "five")
numbers.map { it.length }.filter { it > 3 }.let {
 println(it)
}
// 람다 대신 메서드 참조 (::) 사용
val numbers = mutableListOf("one", "two", "three", "four", "five")
numbers.map { it.length }.filter { it > 3 }.let(::println)
null이 될 수 없는 객체에 대해 ?.과 같이 사용
val str: String = "Hello"
val length = str?.let {
 println("let() called on $it)
 processNonNullString(it) 
 it.length
}
-> null이 아닐 때만 실행
run
수신 객체는 this로 사용가능하고, return 값은 람다의 결과이다.
run은 with 와 같은 일을 하지만 let과 같이 수신 객체에 대한 확장함수이다.
run 은 람다가 객체의 초기화와 return값에 대한 계산을 모두 할 경우 유용하다.
확장함수이기 때문이 .?을 붙여 non-null 제약을 걸 수 있다.
val square = run {
 val width= 10
 val height = 10
 Square(name, age)
}
with
with 는 확장함수가 아니므로 수신 객체를 인자로 전달하지만, 람다 내부에서 this 로 사용가능하다. return 값은 람다 실행 결과이다.
람다 결과과 필요하지 않거나 제공하지 않고, 수신 객체 내에서 함수를 호출하는 경우 with 를 사용하는 것이 좋다.
with this object, do the following.
val numbers = mutableListOf("one", "two", "three", "four", "five")
with(numbers) {
 println("'with' is called with argument $this")
 println("It contains $size elements")
}
// 호출 결과는 사용하지 않는다.
apply
수신 객체는 this로 사용가능하고, return 값은 객체 자신이다.
값을 반환하지 않고, 수신 객체의 멤버가 주로 연산할 때 apply 를 사용하면 좋다.
Builder 패언과 동일한 용도로 사용된다.
대표적으로 객체를 초기화 할 때 사용
val user = User(name = "yeseul").apply {
 age = 27
}
also
also 는 확장함수 이므로 수신 객체를 this 를 사용한다. 그러나 코드블럭 내에서 this 를 파라미터로 입력하므로, it 을 통해 프로퍼티에 접근할 수 있다.
반환 결과가 객체 자신이며, Builder 패턴과 동일하게 사용된다.
객체의 속성을 전혀 사용하지 않거나 변경하지 않는 경우 사용하면 좋다. 객체의 유효성 확인, 로그, 디버깅 등의 목적으로 사용
val numbers = mutableListOf("one", "two", "three")
numbers
 .also { println("The list elements before adding new one: $it") }
 .add("four")
출처
Kotlin In Action
kotlin 공식 문서
https://mycool0905.github.io/kotlin/2020/12/15/kotlin-scope-function.html

[Kotlin] Scope Function

댓글