ꡬκΈμμ μ 곡νλ κ΅μ‘μλ£λ₯Ό μ 리νκΈ° μν ν¬μ€νΈμ λλ€.
kotlinμμλ κ±°μ λͺ¨λ κ²μ΄ ννμμ΄λ©° κ°μ΄ μμ΅λλ€.
val temperature = 20
val isHot = if (temperature > 40) true else false
println(isHot) // false
Kotlin.Unit
μ΄ κ°μ΄ λ μ μμ΅λλ€.
val isUnit = println("This is an expression")
isUnit // This is an expression
println(isUnit) // Kotlin.Unit
note:
Kotlin.Unit
μ μλ°μμ voidμ κ°μ μν μ ν©λλ€.
μλ°μμ voidλ 리ν΄κ°μ΄ μμμ λνλ΄μ§λ§Kotlin.Unit
μ μΈμλ‘λ μ¬μ©ν μ μμ΅λλ€.
"Hello World" λ₯Ό μΆλ ₯νλ κ°λ¨ν μμ μ λλ€.
fun printHello() {
println("Hello World")
}
printHello()
ν¨μμ returnκ°μ΄ μμ κ²½μ° retrun typeμ Unit
μ΄λ©° μλ½λ μ μμ΅λλ€.
fun printHello(name: String?): Unit {
println("Hi there!")
}
맀κ°λ³μμ κΈ°λ³Έκ°μ μ€μ ν μ μμ΅λλ€.
fun drive(speed: String = "fast") {
println("driving $speed")
}
drive() β driving fast
drive("slow") β driving slow
drive(speed = "turtle-like") β driving turtle-like
맀κ°λ³μμ κΈ°λ³Έκ°μ΄ μλ κ²½μ° κ°μ λ©λλ€.
fun tempToday(day: String, temp: Int) {
println("Today is $day and it's $temp degrees.")
}
tempToday("monday", 35)
κΈ°λ³Έ 맀κ°λ³μμ, νμ 맀κ°λ³μλ₯Ό νΌν©νμ¬ μ¬μ©ν μ μμ΅λλ€.
fun reformat(str: String,
divideByCamelHumps: Boolean,
wordSeparator: Char,
normalizeCase: Boolean = true){ }
reformat("Today is a day like no other day", false, '_')
κ°λ
μ±μ λμ΄κΈ° μν΄ νμ λ³μμ λν΄ μ§μ λ λ³μλ₯Ό μ¬μ©ν©λλ€.
Positional arguments(str)
λ€μ Keyword arguments(divideByCamelHumps)
λ₯Ό λλ κ²μ΄ μ’μ μ€νμΌλ‘ κ°μ£Όλ©λλ€.
reformat(str, divideByCamelHumps = false, wordSeparator = '_')
λ³΄λ€ κ°κ²°νκ³ μ½κΈ° μ½κ² ννν μ μμ΅λλ€.
fun double(x: Int): Int {
x * 2
}
fun double(x: Int):Int = x * 2
variables
λ° data structures
μ μ μ₯ν μ μμ΅λλ€.higher-order functions
μ arguments
λ‘ μ λ¬λκ³ λ°νλ μ μμ΅λλ€.higher-order functions
μ μ¬μ©νμ¬ μλ‘μ΄ λ΄μ₯ ν¨μλ₯Ό μμ±ν μ μμ΅λλ€.μ΅λͺ ν¨μλ₯Ό λ§λλ ννμμ λλ€.
var dirtLevel = 20
val waterFilter = {level: Int -> level / 2}
println(waterFilter(dirtLevel)) // 10
funtion typeμ ꡬ문과 λλ€ κ΅¬λ¬Έμ μλ‘ μ°κ΄λμ΄ μμ΅λλ€.
val waterFilter: (Int) -> Int = {level -> level / 2}
ν¨μλ₯Ό 맀κ°λ³μλ‘ μ¬μ©νκ±°λ ν¨μλ₯Ό 리ν΄ν©λλ€.
fun encodeMsg(msg: String, encode: (String) -> String): String {
return encode(msg)
}
λλ²μ§Έ argument
λ‘ μ λ¬λ ν¨μλ₯Ό νΈμΆνκ³ μ²«λ²μ§Έ argument
λ₯Ό μ λ¬ν©λλ€.
μμ ν¨μλ₯Ό νΈμΆνλ €λ©΄ String
κ³Ό ν¨μλ₯Ό μ λ¬ ν΄μΌν©λλ€.
val enc1: (String) -> String = { input -> input.toUpperCase() }
println(encodeMsg("abc", enc1))
μ΄λ¬ν λ°©μμ μ¬μ©νλ©΄ ꡬνκ³Ό μ¬μ©λ²μ΄ λΆλ¦¬λ©λλ€.
::
μ°μ°μλ₯Ό μ¬μ©νλ©΄ μ§μ λ ν¨μλ₯Ό λ€λ₯Έ ν¨μμ λν argument
λ‘ μ λ¬ν©λλ€.
fun enc2(input:String): String = input.reversed()
encodeMessage("abc", ::enc2) // μ§μ λ ν¨μλ₯Ό μ λ¬νλ©°, λλ€ λ°©μμ΄ μλλλ€.
argument
μ μ μΈλ λ°©μκ³Ό ::
μ°μ°μλ₯Ό ν΅ν΄ μ§μ ν ν¨μμ λ°©μμ μλ‘ κ°μμΌ ν©λλ€.
ν¨μλ₯Ό μ¬μ©νλ λͺ¨λ 맀κ°λ³μκ° λ§μ§λ§ 맀κ°λ³μμΈ κ²μ μ νΈν©λλ€.
encodeMessage("acronym", { input -> input.toUpperCase() })
λλ€λ₯Ό κ΄νΈ μμ λ£μ§ μκ³ λ§€κ°λ³μλ‘ μ λ¬ν μ μμ΅λλ€.
encodeMsg("acronym") { input -> input.toUpperCase() }
kotlinμ λ§μ λ΄μ₯ ν¨μλ λ§μ§λ§ 맀κ°λ³μ νΈμΆ ꡬ문μ μ¬μ©νμ¬ μ μλ©λλ€.
inline fun repeat(times: Int, action: (Int) -> Unit)
repeat(3) {
println("Hello")
}
list
μ λͺ©λ‘ μ€ νΉμ 쑰건μ λ§μ‘±νλ νλͺ©μ κ°μ Έμ΅λλ€.
function literal
μ 맀κ°λ³μκ° νλλ§ μλ κ²½μ° ν΄λΉ μ μΈκ³Ό ->
λ₯Ό μλ΅ν μ μμ΅λλ€. 맀κ°λ³μλ it
μ΄λΌ νννλ©° μμμ μΌλ‘ μ μΈλ©λλ€.
val ints = listOf(1, 2, 3)
ints.filter { it > 0 }
νν°λ collection
μ λ°λ³΅νλ©° it
μ λ°λ³΅νλ λμ element
μ κ°μ
λλ€.
μλμ κ°μ΄ ννν μ μμ΅λλ€.
ints.filter { n: Int -> n > 0 }
ints.filter { n -> n > 0 }
μ€κ΄νΈ{}
μμ 쑰건μ νν°κ° λ°λ³΅λ λ μνλλ©°, μ‘°κ±΄μ΄ true
μΌ κ²½μ° νλͺ©μ ν¬ν¨ μν΅λλ€.
val books = listOf("nature", "biology", "birds")
println(books.filter { it[0] == 'b' }) // [biology, birds]
list
μ ννμ νκ°
list
Lazy νκ°μ κ²½μ° μ 체 κ²°κ³Όκ° νμνμ§ μκ±°λ list
κ° ν¬κ³ μ¬λ¬ 볡μ¬λ³ΈμΌλ‘ μΈν λ©λͺ¨λ¦¬ λλΉλ₯Ό νΌν λ μ μ©ν©λλ€.
νν°λ κΈ°λ³Έμ μΌλ‘ Eager λ°©μμ
λλ€. νν°λ₯Ό μ¬μ©ν λλ§λ€ μλ‘μ΄ list
κ° μμ±λ©λλ€.
val instruments = listOf("viola", "cello", "violin")
val eager = instruments.filter { it [0] == 'v' }
println("eager: " + eager) // eager: [viola, violin]
Sequences
λ Lazy νκ°λ₯Ό μ¬μ©νλ data structures
μ΄λ€. νν°μ ν¨κ» μ¬μ©ν΄μ Lazy μν¬ μ μμ΅λλ€.
val instruments = listOf("viola", "cello", "violin")
val filtered = instruments.asSequence().filter { it[0] == 'v'}
println("filtered: " + filtered) // filtered: kotlin.sequences.FilteringSequence@386cc1c4
toList()
λ₯Ό μ¬μ©ν΄μ Sequences
λ₯Ό list
λ‘ λλ릴 μ μμ΅λλ€.
val filtered = instruments.asSequence().filter { it[0] == 'v'}
val newList = filtered.toList()
println("new list: " + newList) // new list: [viola, violin]
note: νν°κ° μ°μμ μΌλ‘ μ¬μ©λλ©΄ Eager λ°©μμ κ²½μ° κ°κ°μ νν°μμ μλ‘μ΄
list
λ₯Ό μμ±νκ³ μ‘°κ±΄μ μΌμΉνλ μlist
return ν©λλ€. λ°λ©΄μ Lazy λ°©μμ κ²½μ° λͺ¨λ 쑰건μ μ²λ¦¬ν λ€list
λ₯Ό return ν©λλ€.
map()
μ λͺ¨λ νλͺ©μ λν΄ λμΌν transformμ μ§ννκ³ list
λ₯Ό return ν©λλ€.val numbers = setOf(1, 2, 3)
println(numbers.map { it * 3 }) // [3, 6, 9]
flatten()
μ μ€μ²©λ collections
μ λν λͺ¨λ elements
λ₯Ό νλμ list
λ‘ return ν©λλ€.val numberSets = listOf(setOf(1, 2, 3), setOf(4, 5), setOf(1, 2))
println(numberSets.flatten()) // [1, 2, 3, 4, 5, 1, 2]