How to check the type of a Variable in Kotlin

Introduction:

Kotlin, being a statically typed programming language, provides a robust type system that ensures type safety and prevents runtime errors. In certain scenarios, you may need to check the type of a variable to make decisions or perform specific operations. In this blog post, we’ll explore various ways to check the variable type in Kotlin

Method 1: Using is operator

The is operator is used to check variable type in Kotlin. It returns true if a variable is of a specific type and returns false otherwise.

        fun checkVariable(myStr: Any){
            if(myStr is String){
                println("Variable is String")
            }
            else if(myStr is Int){
                println("Variable is Integer")
            }
            else{
                println("Variable is Unknown")
            }
        }

In the above example, we use the is operator to check if the variable is a String or an Int.

Method 2: Using when Expression

The when expression in Kotlin is a powerful tool for branching based on the type of a variable. It can be thought of as a more versatile replacement for the traditional switch statement.

        when (myStr) {
            is String -> {
                println("Variable is String")
            }
            is Int -> {
                println("Variable is Integer")
            }
            else -> {
                println("Variable is Unknown")
            }
        }

The when expression allows you to check multiple types in a concise and readable manner.

Method 3: Using ::class Property

The ::class property in Kotlin returns the runtime class of an expression. You can use it to check the type of a variable.

        when (myStr::class) {
            String::class -> {
                println("Variable is String")
            }
            Int::class -> {
                println("Variable is Integer")
            }
            else -> {
                println("Variable is Unknown")
            }
        }

This approach is useful when you need to compare the exact class of a variable.

Method 4: Using as? safe cast operator

The as? operator in Kotlin is used for safe casting. It attempts to cast the variable to the specified type and returns null if the cast is not possible.

        fun checkVariable(myStr: Any){
            val str = myStr as? String
            if(str != null){
                println("Variable is String")
            }
            else{
                println("Variable is not String")
            }
        }

Conclusion:

In conclusion, Kotlin offers several ways to check variable types, each with its use cases. Depending on your specific scenario, you can choose the method that best suits your needs. Happy coding!