Tìm hiểu căn bản về Kotlin

Giới thiệu

Bây giờ, khi Apple đã thay thế Objective-C bằng Swift cho iOS, việc thiếu một ngôn ngữ hiện đại hơn để phát triển ứng dụng Android đã trở nên rõ ràng hơn. Vì vậy, Kotlin - một ngôn ngữ dựa trên JVM đã được JetBrains cho ra đời. Bài viết sau đây sẽ tìm hiểu những điều căn bản nhất về một ngôn ngữ lập trình Kotlin.

Cú pháp cơ bản

Định nghĩa package

Đặc tả package được đặt ở đầu của file source code

package my.demo

import java.util.*

// ...

Không bắt buộc phải match thư mục và package: file source code có thể được đặt tuỳ tiện trong hệ thống file.

Định nghĩa function

Function có 2 tham số kiểu Int và trả về kết quả kiểu Int:

fun sum(a: Int, b: Int): Int {
    return a + b
}

fun main(args: Array<String>) {
    print("sum of 3 and 5 is ")
    println(sum(3, 5))
}
-----------
Kết quả: sum of 3 and 5 is 8

Function có kiểu kết quả trả về được suy ra từ body biểu thức:

fun sum(a: Int, b: Int) = a + b

fun main(args: Array<String>) {
    println("sum of 19 and 23 is ${sum(19, 23)}")
}
----------
Kết quả: sum of 19 and 23 is 42

Function trả về kết quả không có ý nghĩa:

fun printSum(a: Int, b: Int): Unit {
    println("sum of $a and $b is ${a + b}")
}

fun main(args: Array<String>) {
    printSum(-1, 8)
}
----------
Kết quả: sum of -1 and 8 is 7

Kiểu trả về Unit có thể được bỏ qua:

fun printSum(a: Int, b: Int) {
    println("sum of $a and $b is ${a + b}")
}

fun main(args: Array<String>) {
    printSum(-1, 8)
}
----------
Kết quả: sum of -1 and 8 is 7

Định nghĩa biến cục bộ (local)

Biến local chỉ gán giá trị một lần(biến chỉ đọc):

fun main(args: Array<String>) {
    val a: Int = 1  // immediate assignment
    val b = 2   // `Int` type is inferred
    val c: Int  // Type required when no initializer is provided
    c = 3       // deferred assignment
    println("a = $a, b = $b, c = $c")
}
----------
Kết quả: a = 1, b = 2, c = 3

Biến có thể thay đổi:

fun main(args: Array<String>) {
    var x = 5 // `Int` type is inferred
    x += 1
    println("x = $x")
}
----------
Kết quả: x = 6

Comment

Giống như Java và JavaScript, Kotlin hỗ trợ các kiểu end-of-line và block comments.

// This is an end-of-line comment

/* This is a block comment
   on multiple lines. */

Không giống Java, các block comment trong Kotlin có thể lồng nhau.

Sử dụng String template

fun main(args: Array<String>) {
    var a = 1
    // simple name in template:
    val s1 = "a is $a" 

    a = 2
    // arbitrary expression in template:
    val s2 = "${s1.replace("is", "was")}, but now is $a"
    println(s2)
}
----------
Kết quả: a was 1, but now is 2

Sử dụng các biểu thức có điều kiện

fun maxOf(a: Int, b: Int): Int {
    if (a > b) {
        return a
    } else {
        return b
    }
}

fun main(args: Array<String>) {
    println("max of 0 and 42 is ${maxOf(0, 42)}")
}
----------
Kết quả: max of 0 and 42 is 42

Sử dụng if như một biểu thức:

fun maxOf(a: Int, b: Int) = if (a > b) a else b

fun main(args: Array<String>) {
    println("max of 0 and 42 is ${maxOf(0, 42)}")
}
----------
Kết quả: max of 0 and 42 is 42

Sử dụng các giá trị nullable và check null

Trong kotlin, một tham chiếu phải được đánh dấu là nullable khi giá trị null là có thể. Trả về giá trị null nếu str không giữ một số nguyên:

fun parseInt(str: String): Int? {
    // ...
}

Sử dụng function trả về giá trị nullable:

fun parseInt(str: String): Int? {
    return str.toIntOrNull()
}

fun printProduct(arg1: String, arg2: String) {
    val x = parseInt(arg1)
    val y = parseInt(arg2)

    // Using `x * y` yields error because they may hold nulls.
    if (x != null && y != null) {
        // x and y are automatically cast to non-nullable after null check
        println(x * y)
    }
    else {
        println("either '$arg1' or '$arg2' is not a number")
    }    
}

fun main(args: Array<String>) {
    printProduct("6", "7")
    printProduct("a", "7")
    printProduct("a", "b")
}
----------
Kết quả: 
42
either 'a' or '7' is not a number
either 'a' or 'b' is not a number

Kiểm tra và tự động ép kiểu

Toán tử is kiểm tra nếu một biểu thức là một thể hiện của một kiểu. Nếu một biến địa phương loại chỉ đọc hay một thuộc tính được kiểm tra cho một kiểu cụ thể thì không cần ép kiểu một cách rõ ràng:

fun getStringLength(obj: Any): Int? {
    if (obj is String) {
        // `obj` is automatically cast to `String` in this branch
        return obj.length
    }

    // `obj` is still of type `Any` outside of the type-checked branch
    return null
}


fun main(args: Array<String>) {
    fun printLength(obj: Any) {
        println("'$obj' string length is ${getStringLength(obj) ?: "... err, not a string"} ")
    }
    printLength("Incomprehensibilities")
    printLength(1000)
    printLength(listOf(Any()))
}
----------
Kết quả: 
'Incomprehensibilities' string length is 21 
'1000' string length is ... err, not a string 
'[java.lang.Object@6b884d57]' string length is ... err, not a string 

Sử dụng vòng lặp for

fun main(args: Array<String>) {
    val items = listOf("apple", "banana", "kiwi")
    for (item in items) {
        println(item)
    }
}
----------
Kết quả: 
apple
banana
kiwi

hoặc:

fun main(args: Array<String>) {
    val items = listOf("apple", "banana", "kiwi")
    for (index in items.indices) {
        println("item at $index is ${items[index]}")
    }
}
----------
Kết quả: 
item at 0 is apple
item at 1 is banana
item at 2 is kiwi

Sử dụng vòng lặp while

fun main(args: Array<String>) {
    val items = listOf("apple", "banana", "kiwi")
    var index = 0
    while (index < items.size) {
        println("item at $index is ${items[index]}")
        index++
    }
}
----------
Kết quả: 
item at 0 is apple
item at 1 is banana
item at 2 is kiwi

Sử dụng biểu thức when

fun describe(obj: Any): String =
when (obj) {
    1          -> "One"
    "Hello"    -> "Greeting"
    is Long    -> "Long"
    !is String -> "Not a string"
    else       -> "Unknown"
}

fun main(args: Array<String>) {
    println(describe(1))
    println(describe("Hello"))
    println(describe(1000L))
    println(describe(2))
    println(describe("other"))
}
----------
Kết quả: 
One
Greeting
Long
Not a string
Unknown

Sử dụng ranger (dãy ..)

Để kiểm tra một số có thuộc một dãy, sử dụng toán tử in:

fun main(args: Array<String>) {
    val x = 10
    val y = 9
    if (x in 1..y+1) {
        println("fits in range")
    }
}
----------
Kết quả: fits in range

Kiểm tra một số nằm ngoài dãy:

fun main(args: Array<String>) {
    val list = listOf("a", "b", "c")

    if (-1 !in 0..list.lastIndex) {
        println("-1 is out of range")
    }
    if (list.size !in list.indices) {
        println("list size is out of valid list indices range too")
    }
}
----------
Kết quả: 
-1 is out of range
list size is out of valid list indices range too

Sử dụng collection

Iterating trên một collection:

fun main(args: Array<String>) {
    val items = listOf("apple", "banana", "kiwi")
    for (item in items) {
        println(item)
    }
}
----------
Kết quả: 
apple
banana
kiwi

Kiểm tra nếu một collection có chứa một đối tượng, sử dụng toán tử in:

fun main(args: Array<String>) {
    val items = setOf("apple", "banana", "kiwi")
    when {
        "orange" in items -> println("juicy")
        "apple" in items -> println("apple is fine too")
    }
}
----------
Kết quả: apple is fine too

Sử dụng biểu thức lamda để filter và map collection:

fun main(args: Array<String>) {
    val fruits = listOf("banana", "avocado", "apple", "kiwi")
    fruits
    .filter { it.startsWith("a") }
    .sortedBy { it }
    .map { it.toUpperCase() }
    .forEach { println(it) }
}
----------
Kết quả:
APPLE
AVOCADO

Idioms

Tạo các DTOs (POJOs/POCOs)

data class Customer(val name: String, val email: String)

cung cấp một class Customer với các function sau:

• getters (và setters trong trường hợp các biến var) cho tất cả các thuộc tính
• equals()
• hashCode()
• toString()
• copy()
• component1(), component2(), .. cho tất cả các thuộc tính

Giá trị mặc định cho các tham số của function

fun foo(a: Int = 0, b: String = "") { ... }

Lọc một danh sách

val positives = list.filter { x -> x > 0 }

hoặc cách khác ngắn gọn hơn:

val positives = list.filter { it > 0 }

String Interpolation

println("Name $name")

Check các thể hiện

when (x) {
    is Foo -> ...
    is Bar -> ...
    else   -> ...
}

Thuộc tính lazy

val p: String by lazy {
    // compute the string
}

Mở rộng function

fun String.spaceToCamelCase() { ... }

"Convert this to camelcase".spaceToCamelCase()

Tạo một singleton

object Resource {
    val name = "Name"
}

Check null ngắn gọn

val files = File("Test").listFiles()

println(files?.size)

Biểu thức try/catch

fun test() {
    val result = try {
        count()
    } catch (e: ArithmeticException) {
        throw IllegalStateException(e)
    }

    // Working with result
}

Biểu thức if

fun foo(param: Int) {
    val result = if (param == 1) {
        "one"
    } else if (param == 2) {
        "two"
    } else {
        "three"
    }
}

Kết luận

Trên đây là những điều cơ bản về cú pháp và các idiom của Kotlin. Hy vọng sẽ giúp các bạn tiếp cận, làm quen với ngôn ngữ lập trình mới này một cách căn bản và sơ khai nhất.