"Kotlin invoke()"의 두 판 사이의 차이

 
(사용자 2명의 중간 판 14개는 보이지 않습니다)
1번째 줄: 1번째 줄:
{{다른뜻|invoke}}
==개요==
==개요==
;Kotlin invoke()
;Kotlin invoke()
* 인스턴스 변수를 함수처럼 사용할 수 있게 해준다.
:호출하면 invoke() 함수가 실행되는 것.
* 일반적으로 자신(this)을 반환하여, invoke를 반복할 수 있게 한다.
* 반드시 그래야 하는 것은 아니다. 다만 자신을 반환하지 않으면 invoke를 반복할 수 없겠지.
* 매개변수를 받는 것도 가능하다.


<source lang='kotlin'>
==#Jmnote==
class Invokable {
* 상당히 독특한 문법인데, 용도는 ... 잘 모르겠다.
    var numberOfInvocations: Int = 0
* 일반적으로 this를 반환하는 경우는 chaining을 위한 것인데...
        private set
* 한가지 메소드만 chaining으로 반복하여 호출할 경우가 있으려나?
     operator fun invoke(): Invokable {
* 지금으로서는 이것 대신 람다 함수 또는 연산자 정의를 활용하는 것이 직관적일 것 같다.
         numberOfInvocations++
* 재귀함수와 비교: 재귀함수는 특별한 구문은 없고 단순히 자기 자신을 호출하는 것인데, invoke()는 자기 자신(인스턴스)을 함수로서 호출하는 길을 열어주는 것이다.
 
==예시==
<syntaxhighlight lang='kotlin' run>
class MyPrinter {
     operator fun invoke(str: String): MyPrinter {
         print(str)
         return this
         return this
     }
     }
}
}
 
fun main(args: Array<String>) {
fun invokeTwice(invokable: Invokable) = invokable()()
    val myprint = MyPrinter()
</source>
    myprint("Hello")("World")("1")("2")("3")
<source lang='kotlin'>
    // HelloWorld123
}
</syntaxhighlight>
<syntaxhighlight lang='kotlin' run>
class Foo {
class Foo {
     var count = 0;
     var count = 0
     operator fun invoke(): Foo {
     operator fun invoke(): Foo {
         count++
         count++
24번째 줄: 39번째 줄:
fun main(args: Array<String>) {
fun main(args: Array<String>) {
     val foo = Foo()
     val foo = Foo()
     foo()()()()
     foo()()()()()
     println("foo.count = [${foo.count}]")
     println("foo.count=${foo.count}")
     // foo.count = [4]
     // foo.count=5
}
</syntaxhighlight>
<syntaxhighlight lang='kotlin' run>
class Invokable {
    var numberOfInvocations: Int = 0
        private set
    operator fun invoke(): Invokable {
        numberOfInvocations++
        println("numberOfInvocations=${numberOfInvocations}");
        return this
    }
}
}
</source>
fun invokeTwice(invokable: Invokable) = invokable()()
<source lang='kotlin'>
fun main(args: Array<String>) {
    invokeTwice(Invokable())
    // numberOfInvocations=1
    // numberOfInvocations=2
}
</syntaxhighlight>
<syntaxhighlight lang='kotlin' run>
class Foo {
class Foo {
     var count = 0;
     var count = 0;
41번째 줄: 73번째 줄:
     val foo1 = Foo()
     val foo1 = Foo()
     val foo2 = invokeTwice(foo1)
     val foo2 = invokeTwice(foo1)
     println("foo1.count=[${foo1.count}]")  
     println("foo1.count=${foo1.count}")  
     // foo1.count=[2]
     // foo1.count=2
     println("foo2.count=[${foo2.count}]")
     println("foo2.count=${foo2.count}")
     // foo2.count=[2]
     // foo2.count=2
}
</syntaxhighlight>
<syntaxhighlight lang='kotlin' run>
class Person(val name: String) {
    operator fun invoke(): String {
        println("Invoked...");
        return "Hello, I'm ${name}"
    }
}
fun main(args: Array<String>) {
    val p = Person("John")
    println( p() )
    // Invoked...
    // Hello, I'm John
}
}
</source>
</syntaxhighlight>


==참고==
==참고==

2021년 7월 29일 (목) 10:22 기준 최신판

  다른 뜻에 대해서는 invoke 문서를 참조하십시오.

1 개요[ | ]

Kotlin invoke()
  • 인스턴스 변수를 함수처럼 사용할 수 있게 해준다.
호출하면 invoke() 함수가 실행되는 것.
  • 일반적으로 자신(this)을 반환하여, invoke를 반복할 수 있게 한다.
  • 반드시 그래야 하는 것은 아니다. 다만 자신을 반환하지 않으면 invoke를 반복할 수 없겠지.
  • 매개변수를 받는 것도 가능하다.

2 #Jmnote[ | ]

  • 상당히 독특한 문법인데, 용도는 ... 잘 모르겠다.
  • 일반적으로 this를 반환하는 경우는 chaining을 위한 것인데...
  • 한가지 메소드만 chaining으로 반복하여 호출할 경우가 있으려나?
  • 지금으로서는 이것 대신 람다 함수 또는 연산자 정의를 활용하는 것이 직관적일 것 같다.
  • 재귀함수와 비교: 재귀함수는 특별한 구문은 없고 단순히 자기 자신을 호출하는 것인데, invoke()는 자기 자신(인스턴스)을 함수로서 호출하는 길을 열어주는 것이다.

3 예시[ | ]

class MyPrinter {
    operator fun invoke(str: String): MyPrinter {
        print(str)
        return this
    }
}
fun main(args: Array<String>) {
    val myprint = MyPrinter()
    myprint("Hello")("World")("1")("2")("3")
    // HelloWorld123
}
class Foo {
    var count = 0
    operator fun invoke(): Foo {
        count++
        return this
    }
}
fun main(args: Array<String>) {
    val foo = Foo()
    foo()()()()()
    println("foo.count=${foo.count}")
    // foo.count=5
}
class Invokable {
    var numberOfInvocations: Int = 0
        private set
    operator fun invoke(): Invokable {
        numberOfInvocations++
        println("numberOfInvocations=${numberOfInvocations}");
        return this
    }
}
fun invokeTwice(invokable: Invokable) = invokable()()
fun main(args: Array<String>) {
    invokeTwice(Invokable())
    // numberOfInvocations=1
    // numberOfInvocations=2
}
class Foo {
    var count = 0;
    operator fun invoke(): Foo {
        count++
        return this
    }
}
fun invokeTwice(foo: Foo) = foo()()
fun main(args: Array<String>) {
    val foo1 = Foo()
    val foo2 = invokeTwice(foo1)
    println("foo1.count=${foo1.count}") 
    // foo1.count=2
    println("foo2.count=${foo2.count}")
    // foo2.count=2
}
class Person(val name: String) {
    operator fun invoke(): String {
        println("Invoked...");
        return "Hello, I'm ${name}"
    }
}
fun main(args: Array<String>) {
    val p = Person("John")
    println( p() )
    // Invoked...
    // Hello, I'm John
}

4 참고[ | ]

문서 댓글 ({{ doc_comments.length }})
{{ comment.name }} {{ comment.created | snstime }}