How do you use Kotlin extensions to enhance the functionality of existing classes?

1 What are extensions?

Extensions are a way of adding new functions or properties to a class, without changing its original definition or creating a subclass. You can define extensions for any class, even if it is part of a library or a framework that you do not control. Extensions are resolved statically at compile time, meaning that they do not affect the actual class or its instances, but only provide an alternative way of calling them. Extensions are declared with the dot notation, followed by the name of the class that they extend. For example, you can define an extension function for the String class that reverses its characters:

fun String.reverse(): String {
  return this.reversed()
}        

You can then call this function on any String object, as if it was a member function:

val name = "Kotlin"
val reversedName = name.reverse() // "niltok"        

4 How to use extensions?

To use an extension function or property, you need to import it in the file where you want to use it, unless it is defined in the same file or in the same package. You can import extensions by using the import keyword, followed by the name of the file or the package where they are defined, and the name of the extension. For example, if you have defined an extension function for the List class that shuffles its elements in a file called Extensions.kt, you can import it in another file like this: import Extensions.shuffle You can then use this function on any List object, as if it was a member function:

val list = listOf(1, 2, 3, 4, 5)
list.shuffle() // [3, 5, 1, 4, 2]        

5 How to avoid conflicts?

Sometimes, you may encounter a situation where an extension function or property has the same name as a member function or property of the class that you are extending. In this case, the member function or property will always take precedence over the extension, and the extension will be ignored. To avoid this, you should always choose a unique name for your extensions, or use a prefix or a suffix to distinguish them from the members. For example, if you want to define an extension function for the String class that returns its length in bytes, you should not name it length, as this is already a member property of the String class. Instead, you could name it lengthInBytes, or use an underscore as a prefix or a suffix:

fun String._lengthInBytes(): Int {
  return this.toByteArray().size
}
fun String.lengthInBytes_(): Int {
  return this.toByteArray().size
}        

You can then use these functions on any String object, without conflicting with the member property:

val text = "Hello"
val length = text.length // 5
val lengthInBytes = text._lengthInBytes() // 5
val lengthInBytes_ = text.lengthInBytes_() // 5