Listed here are a couple of Necessary options of Kotlin that we are able to use to enhance our coding course of.
Use of Unit and Nothing
In Kotlin, Unit and Nothing are two differing kinds with distinct functions.
Unit is a kind with just one worth, additionally referred to as Unit. It represents the absence of a significant worth, much like void in Java. It’s used because the return kind of a perform that doesn’t return any worth, or in different phrases, a perform that solely has unintended effects. For instance:
enjoyable printHelloWorld(): Unit {
println("Hey, World!")
}
Within the above instance, the printHelloWorld perform returns Unit as a result of it solely prints a message to the console, with out returning any significant worth.
However, Nothing is a kind with no values. It’s used to point {that a} perform won’t ever return usually. For instance, if a perform throws an exception, its return kind may be declared as Nothing, as a result of it is going to by no means attain its return assertion:
enjoyable fail(): Nothing {
throw RuntimeException("Failed")
}
Within the above instance, the fail perform returns Nothing as a result of it at all times throws an exception and by no means returns usually.
In abstract, Unit is used to symbolize the absence of a significant worth, whereas Nothing is used to point {that a} perform won’t ever return usually.
Destructuring
In Kotlin, you possibly can declare and initialize a number of variables in the identical line utilizing destructuring declarations.
Destructuring declarations mean you can break down a knowledge construction (corresponding to a listing or a map) into its particular person parts and assign them to variables in a single step.
Right here’s an instance of the right way to use destructuring declarations to initialize a number of variables directly:
val (x, y, z) = listOf(1, 2, 3)
Within the above instance, we declare three variables x, y, and z, and initialize them with the values from the listOf perform name. The values are assigned to the variables in the identical order as they seem within the record.
You may also use destructuring declarations with maps, the place you possibly can destructure the key-value pairs into separate variables:
val map = mapOf("title" to "Alice", "age" to 30)
val (title, age) = map
Within the above instance, we declare two variables title and age, and initialize them with the values from the map variable. The keys "title" and "age" are used to destructure the values into separate variables.
Destructuring declarations is a handy approach to initialize a number of variables in a single line of code and may make your code extra concise and expressive.
Use typealias
n Kotlin, a kind alias is a approach to create a brand new title for an current kind. It doesn’t create a brand new kind, however supplies another title for an current one, which may make your code extra readable and expressive.
Right here’s an instance of a kind alias in Kotlin:
typealias UserName = String
Within the above instance, we create a kind alias UserName for the String kind. Which means wherever UserName is used, it will likely be handled as a String.
We are able to use this alias in our code to make it extra expressive. For instance:
enjoyable printUserName(title: UserName) {
println("Consumer title is: $title")
}
val userName: UserName = "Alice"
printUserName(userName)
Within the above instance, we use the UserName alias to make the printUserName perform parameter extra descriptive. We additionally use the alias to declare a userName variable.
One other instance of a kind alias may very well be to create a shorter title for a posh kind:
typealias IntArray2D = Array<IntArray>
Within the above instance, we create a kind alias IntArray2D for the Array<IntArray> kind, which represents a two-dimensional array of integers. This will make it simpler to work with such an array in our code.
Sort aliases are a easy however highly effective characteristic in Kotlin that may make your code extra expressive and readable.
Use property delegation to extract frequent property patterns
An vital instance is the observable property — a property that does one thing every time it’s modified. As an illustration, let’s say that you’ve got a listing adapter drawing a listing. Each time information change inside it, we have to redraw modified objects. Otherwise you would possibly have to log all modifications to a property. Each instances may be carried out utilizing observable from stdlib:
var objects: Checklist<Merchandise> by Delegates.observable(listOf()) { _, _, _ ->
notifyDataSetChanged()
}
var key: String? by
Delegates.observable(null) { _, outdated, new ->
Log.e("key modified from $outdated to $new")
}
Use Lazy
The lazy key phrase is beneficial when you’ve gotten a property that requires costly computation or initialization and also you need to defer that computation till it is truly wanted. By utilizing lazy, you possibly can keep away from pointless computations and enhance the efficiency of your code.
Right here’s an instance of the right way to use lazy:
val myExpensiveProperty: String by lazy {
// costly computation or initialization
"Hey, World!"
}
On this instance, myExpensiveProperty is said as a String property that’s initialized lazily. The lambda handed to lazy incorporates the costly computation or initialization that’s solely carried out when myExpensiveProperty is accessed for the primary time. On this case, the lambda returns the string "Hey, World!".
After the primary entry, the worth of myExpensiveProperty is cached and reused for subsequent accesses. This may help enhance the efficiency of your code by avoiding pointless computations.
It’s vital to notice that lazy properties are thread-safe by default, which implies that the initialization code is executed solely as soon as even when a number of threads entry the property concurrently. Nonetheless, if that you must customise the thread-safety habits, you need to use the LazyThreadSafetyMode enum to specify the specified habits.
In abstract, the lazy key phrase in Kotlin is used to create lazily initialized properties, which may help enhance the efficiency of your code by deferring costly computations or initializations till they’re truly wanted.
Use takeIf
In Kotlin, takeIf is a normal library perform that lets you carry out a conditional operation on an object and return the article if the situation is true, or null if the situation is fake. It has the next signature:
inline enjoyable <T> T.takeIf(predicate: (T) -> Boolean): T?
The takeIf perform takes a lambda expression as its argument, which returns a Boolean worth. If the lambda returns true for the article on which the perform known as, then the article is returned by the takeIf perform. In any other case, null is returned.
Right here’s an instance of the right way to use takeIf:
val str: String? = "Hey, World!"
val size = str?.takeIf { it.size > 5 }?.size
On this instance, takeIf is used to examine whether or not the size of the str string is larger than 5. Whether it is, then the takeIf perform returns the unique string, which is then chained to the size property to get the size of the string. If the size is just not larger than 5, then null is returned and the size variable is assigned null.
One other instance may very well be utilizing takeIf to filter a listing based mostly on a situation, like this:
val numbers = listOf(1, 2, 3, 4, 5)
val evenNumber = numbers.firstOrNull { it % 2 == 0 }?.takeIf { it > 2 }
On this instance, takeIf is used to examine whether or not the primary even quantity within the numbers record is larger than 2. Whether it is, then the even quantity is returned by the takeIf perform. If not, then null is returned.
Please subscribe and Clap.