Tìm hiểu căn bản về Kotlin
Bài đăng này đã không được cập nhật trong 6 năm
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.
All rights reserved
