Chờ một chút: bạn thấy bài viết có ích chứ? Hãy chia sẻ nó với mọi người nhé!

Cú pháp cơ bản trong lập trình Kotlin

Định nghĩa package trong Kotlin

package my.demo

import java.util.*

// ...

Định nghĩa function trong Kotlin

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

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

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

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) trong Kotlin

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

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

Comment trong Kotlin

// This is an end-of-line comment

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

Sử dụng String template trong Kotlin

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 trong Kotlin

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(, 42)}")
}
----------
Kết quả: max of  and 42 is 42

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(, 42)}")
}
----------
Kết quả: max of  and 42 is 42

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

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

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

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

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  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 = 
    while (index < items.size) {
        println("item at $index is ${items[index]}")
        index++
    }
}
----------
Kết quả: 
item at  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 ..)

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

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

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

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

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)

• 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 = , b: String = "") { ... }

Lọc một danh sách

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

val positives = list.filter { it >  }

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 lập trình 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. 


Chúc các bạn thành công. Đừng quên theo dõi AnonyHome để cập nhật các bài viết mới nhé!