Kotlin get all property value of data class-CodePudding

Is there a syntactic sugar in Kotlin to iterate on each field/property value of a data class?

Sample:

data class User(
    var firstName: String = DEFAULT_VALUE_STRING,
    var middleName: String = DEFAULT_VALUE_STRING,
    var lastName: String = DEFAULT_VALUE_STRING
)

val user = User()

Then check if any of the property's value is empty, considering all of it is String data type with something like this

if (user.properties.any{ it.isBlank() }) {

   // TODO ...

}

CodePudding user response：

Probably the closest you'll get is checking all the values of all the generated componentX() functions (since they're only created for the constructor parameter properties, the "data" in a data class) but yeah that involves reflection.

If I were you, I'd create an interface with a properties property and make all your data classes implement that - something like this:

import kotlin.reflect.KProperty0

interface HasStringProperties {
    val properties: List<KProperty0<String>>
}

data class User(
    var firstName: String = "",
    var middleName: String = "",
    var lastName: String = ""
) : HasStringProperties {
   override val properties = listOf(::firstName, ::middleName, ::lastName)
}

fun main() {
    val user = User("Funny", "", "Name")
    println(user.properties.any {it.get().isBlank()})
}

So no, it's not automatic - but specifying which properties you want to include is simple, and required if you're going to access it on a particular class, so there's an element of safety there.

Also, because you're explicitly specifying String properties, there's type safety included as well. Your example code is implicitly assuming all properties on your data classes will be Strings (or at least, they're a type with an isBlank() function) which isn't necessarily going to be true. You'd have to write type-checking into your reflection code - if you say "I don't need to, the classes will only have String parameters" then maybe that's true, until it isn't. And then the reflection code has to be written just because you want to add a single age field or whatever.

You don't actually have to use property references in Kotlin either, you could just grab the current values:

interface HasStringProperties {
    val properties: List<String>
}

data class User(
    var firstName: String = "",
    var middleName: String = "",
    var lastName: String = ""
) : HasStringProperties {
   // getter function creating a new list of current values every time it's accessed
   override val properties get() = listOf(firstName, middleName, lastName)
}

fun main() {
    val user = User("Funny", "", "Name")
    println(user.properties.any {it.isBlank()})
}

It depends whether you want to be able to reference the actual properties on the class itself, or delegate to a getter to fetch the current values.

And of course you could use generics if you want, list all the properties and use filterIsInstance<String> to pull all the strings. And you could put a function in the interface to handle a generic isEmpty check for different types. Put all the "check these properties aren't 'empty'" code in one place, so callers don't need to concern themselves with working that out and what it means for each property